两种实现多线程方式解决同步问题

快来打我* 2023-10-11 15:28 26阅读 0赞

案例：分别用继承Thread和实现Runable接口的方式实现三个窗口卖票操作。

*  继承Theard方式

public class ThreadTest {
        
    
        public static void main(String[] args) {
        
    
            Ticket ticket1 = new Ticket();
            Ticket ticket2 = new Ticket();
            Ticket ticket3 = new Ticket();
    
            ticket1.setName("1号窗口");
            ticket2.setName("2号窗口");
            ticket3.setName("3号窗口");
    
            ticket1.start();
            ticket2.start();
            ticket3.start();
    
        }
    
    }
    
    class Ticket extends Thread{
        
    
        private int ticket = 100;
    
        @Override
        public void run() {
        
            while (ticket > 0){
        
                System.out.println(getName() + " 正在卖第 " + ticket + " 张票");
                ticket--;
            }
        }
    }

*  实现Runable接口方式

public class RunableTest {
        
    
        public static void main(String[] args) {
        
            Ticket02 ticket02 = new Ticket02();
    
            Thread thread1 = new Thread(ticket02);
            Thread thread2 = new Thread(ticket02);
            Thread thread3 = new Thread(ticket02);
    
            thread1.setName("1号窗口");
            thread2.setName("2号窗口");
            thread3.setName("3号窗口");
    
            thread1.start();
            thread2.start();
            thread3.start();
    
        }
    
    }
    
    class Ticket02 implements Runnable{
        
    
        private int ticket = 100;
    
        @Override
        public void run() {
        
            while (ticket > 0){
        
                System.out.println(Thread.currentThread().getName() + " 正在卖第 " + ticket + " 张票");
                ticket--;
            }
        }
    }

上述这两种方式，都会有线程安全问题，因为可能发生多个线程共同操作同一个对象（数据）。

*  如何解决？

1.  同步方法
2.  同步代码块
3.  ReentrantLock锁

*  继承Thread方式解决线程安全（同步方法方式）

class Ticket extends Thread{
        
    
        private static int ticket = 100;
    
        @Override
        public void run() {
        
            show();
        }
    
        private synchronized static void show() {
        
            while (ticket > 0){
        
           		System.out.println(Thread.currentThread().getName() + " 正在卖第 " + ticket + " 张票");
                ticket--;
            }
        }
    }

在继承Thread类方式实现多线程的同步方法时，需要将同步方法改为静态的，那此时成员变量也需要改为静态的，如果是同步方法的方式，则相当于同步的是Ticket.class对象，类对象是唯一的。synchronized（同步监视器），同步监视器的关键就在于，这个对象在JVM内存中是一定要唯一的。

*  继承Thread方式解决线程安全（同步代码块方式）

class Ticket extends Thread{
        
    
        private static int ticket = 100;
    
        @Override
        public void run() {
        
            show();
        }
    
        private void show() {
        
                while (true){
        
                   synchronized (Ticket.class){
        
                       if (ticket > 0){
        
                           System.out.println(Thread.currentThread().getName() + " 正在卖第 " + ticket + " 张票");
                           ticket--;
                       }else {
        
                           break;
                       }
                   }
            }
        }
    }

此时需要注意两个地方：  
1. synchronized (Ticket.class) synchronized 监视的锁对象一定是唯一的，如果这个地方写this，那么是不行的，因为我们创建了三个线程对象，就会有三个this，所以锁不住，而Ticket.class在JVM内存中是唯一的。  
2. private static int ticket = 100; ticket属性还是要写成静态的，因为如果ticket是成员变量，虽然同步了run方法，但每个线程对象还是判断自己的实例变量的值，而如果将ticket声明为静态的，则所有实例对象共享静态属性和静态方法,那这三个线程对象就会操作一个ticket。

*  Runable接口方式实现（同步方法方式）

class Ticket02 implements Runnable{
        
    
        private int ticket = 100;
    
    
        @Override
        public void run() {
        
            show();
        }
    
        private synchronized void show() {
        
            while (ticket > 0){
        
                System.out.println(Thread.currentThread().getName() + " 正在卖第 " + ticket + " 张票");
                ticket--;
            }
        }
    }

Runable接口方式的同步方法不需要将方法声明为静态的，因为只有一个Ticket实例对象，三个线程来同时操作这一个对象，如果是同步方法的话，此时就是synchronized(this)，this就是当前的Ticket实例对象，由于我们只new 了一个实例对象，所以可以锁住。

*  Runable接口方式实现（同步代码块方式）

class Ticket02 implements Runnable{
        
    
        private int ticket = 100;
    
    
        @Override
        public void run() {
        
            show();
        }
    
        private void show() {
        
            while (true){
        
                synchronized (this){
        
                    if (ticket > 0){
        
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + " 正在卖第 " + ticket + " 张票");
                        ticket--;
                    }else break;
                }
    
            }
        }
    }

这里说一下 线程的sleep()方法，sleep方法为让当前线程变为阻塞状态，释放CPU时间片，让CPU可以去执行其他线程，***但并不能释放当期获取的锁。***