Java多线程同步锁、Lock锁和等待唤醒机制及代码演示

r囧r小猫 2024-02-26 05:55 54阅读 0赞

#### 多线程入门学习路线 ####

*  线程的生命周期
 *  线程的安全问题
 *  同步代码块
 *  同步方法
 *  Lock锁
 *  生产者和消费者（等待唤醒机制）

## 线程的生命周期 ##

![在这里插入图片描述][1807410f4d77454f91ba5d7eabf771d2.png]  
**问：sleep方法会让线程睡眠，睡眠时间到了之后，立马就会执行下面的代码吗?**

解：sleep方法时间到了之后，线程就变成了就绪状态，他会先去抢CPU的执行权，抢到了，才会去执行下面的代码，所以他是有一个抢的过程的。

## 线程的安全问题 ##

线程会帮我们提高程序的效率，但是提高效率的同时，也会有个弊端，就是不安全。

**举个小栗子：**

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

代码如下：

package com.heima.thread001;
    
    public class MyThread extends Thread{
        
    
        int ticket = 0;
        @Override
        public void run() {
        
            while (true){
        
                if (ticket < 100){
        
                    try {
        
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    ticket ++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票 ...");
                }else{
        
                    break;
                }
            }
        }
    }

package com.heima.thread001;
    
    import java.util.concurrent.ExecutionException;
    
    public class TestDemo {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
    
            //创建线程对象
            MyThread t1 = new MyThread();
            MyThread t2 = new MyThread();
            MyThread t3 = new MyThread();
    
            //起名字
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            //开启线程
            t1.start();
            t2.start();
            t3.start();
        }
    }

运行结果：  
![在这里插入图片描述][862e5f1640bd4d04983d10c9d954f64e.png]  
发现有重复卖票的情况，那如何解决呢？请继续看下面的章节哦

## 同步代码块 ##

*  方式：把操作共享数据的代码锁起来
 *  格式：

synchronized (锁对象){
        
      操作共享数据的代码
    }

*  特点1：锁默认打开，有一个线程进去了，锁自动关闭
 *  特点2：里面的代码全部执行完毕，线程出来，锁自动打开

使用同步代码块来解决，上面重复卖票的问题，代码如下：

package com.heima.thread001;
    
    public class MyThread extends Thread{
        
    
        static int ticket = 0;
        //锁对象，一定要是唯一的
        static Object obj = new Object();
        @Override
        public void run() {
        
            while (true){
        
                synchronized (obj){
        
                if (ticket < 100){
        
                    try {
        
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    ticket ++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票 ...");
                }else{
        
                    break;
                }
                }
            }
        }
    }

运行结果：

窗口1正在卖第1张票 ...
    窗口1正在卖第2张票 ...
    窗口2正在卖第3张票 ...
    窗口2正在卖第4张票 ...
    窗口2正在卖第5张票 ...
    窗口2正在卖第6张票 ...
    ....此处省略....
    窗口1正在卖第95张票 ...
    窗口1正在卖第96张票 ...
    窗口1正在卖第97张票 ...
    窗口1正在卖第98张票 ...
    窗口1正在卖第99张票 ...
    窗口1正在卖第100张票 ...
    
    Process finished with exit code 0

**注意点：**

*  锁对象，一定要保持唯一，所以使用static关键字来修饰，确保当前线程类无论创建多少个对象，都共享一个锁对象哦
 *  成员变量ticket，也要保持唯一性，与锁对象一样的思路，确保所以得线程对象共享一个变量
 *  synchronized中的锁对象，不能写成this哦，因为this代表当前线程对象，不同的线程对象，那么对于的锁对象也不一样，这样加锁就没有意义了。因为锁对象不唯一。可以使用以下写法来解决：

//一个类的字节码文件，肯定是唯一的，所以这样写也没有问题
    synchronized (MyThread.class){
        ...}

## 同步方法 ##

*  方式：就是把 synchronized 关键字加的方法上
 *  格式：修饰符 synchronized 返回值类型 方法名 (方法参数) \{ … \}
 *  特点1：同步方法是锁住方法里面所有的代码
 *  特点2：锁对象不能自己指定，是java已经规定好的。如果当前方法是非静态的，那么锁对象为 this，即当前方法的调用者；如果当前方法是静态的，那么锁对象为 当前类的字节码文件对象，比如MyThread.class

接下来，我们使用 同步方法来完成，窗口售票功能，代码入；

package com.heima.thread001;
    
    public class MyRun implements Runnable {
        
    	//此处没有使用static修饰，是因为MyRun只创建了一次对象，所以不需要设置成共享变量哦
        int ticket = 0;
    
        @Override
        public void run() {
        
            while (true){
        
                if (sale()) break;
            }
        }
    
        private synchronized boolean sale() {
        
            if (ticket == 100) {
        
                return true;
            }else {
        
                ticket ++;
                System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票 ...");
            }
            return false;
        }
    }

package com.heima.thread001;
    
    import java.util.concurrent.ExecutionException;
    
    public class TestDemo {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
    
            MyRun myRun = new MyRun();
            //创建线程对象
            Thread t1 = new Thread(myRun);
            Thread t2 = new Thread(myRun);
            Thread t3 = new Thread(myRun);
    
            //起名字
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            //开启线程
            t1.start();
            t2.start();
            t3.start();
        }
    }

运行结果  
![在这里插入图片描述][d4bf42e763ae4d19a92d3f4acd00b99a.png]

## Lock锁 ##

我们知道 synchronized 给代码加锁或解锁时，我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

*  Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
 *  Lock中提供了获得锁和释放锁的方法：  
    void lock();//获得锁  
    void unlock();//释放锁
 *  lock是接口不能直接实例化，这里采用他的实现类ReentrantLock来实例化  
    ReentrantLock的构造方法  
    ReentrantLock()：创建一个ReentrantLock的实例

接下来使用lock锁，来处理卖票的问题

package com.heima.thread001;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class MyRun implements Runnable {
        
        int ticket = 0;
        Lock lock = new ReentrantLock();
        @Override
        public void run() {
        
            while (true){
        
                lock.lock();
                try {
        
                    if (ticket == 100) {
        
                        break;
                    }else {
        
                        ticket ++;
                        System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票 ...");
                    }
                } catch (Exception e) {
        
                    e.printStackTrace();
                } finally {
        
                    lock.unlock();
                }
            }
        }
    }

package com.heima.thread001;
    
    import java.util.concurrent.ExecutionException;
    
    public class TestDemo {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
    
            MyRun myRun = new MyRun();
            //创建线程对象
            Thread t1 = new Thread(myRun);
            Thread t2 = new Thread(myRun);
            Thread t3 = new Thread(myRun);
    
            //起名字
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            //开启线程
            t1.start();
            t2.start();
            t3.start();
        }
    }

## 生产者和消费者（等待唤醒机制） ##

**生产者和消费者是一个十分经典的多线程协作模式**

举个小栗子来说明一下消费者和生产者的等待唤醒过程:  
![在这里插入图片描述][3115b0b9b14243fb9873e06498606cac.png]  
**常见方法：**

*  void wait() 当前线程等待，直到被其他线程唤醒
 *  void notify() 随机唤醒单个线程
 *  void notifyAll() 唤醒所有线程

接下来，使用代码来演示生产者和消费者的等待唤醒过程

消费者代码：

package com.heima.thread001;
    
    public class FoodThread extends Thread {
        
    
        @Override
        public void run() {
        
            while (true){
        
                synchronized (Desk.lock){
        
                    if (Desk.count == 0){
        
                        break;
                    }else {
        
                        //判断桌子上有没有面条
                        if (Desk.foodFlag == 0){
        
                            //如果没有，就等待
                            try {
        
                                Desk.lock.wait();//让当前线程跟锁进行绑定
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();
                            }
                        }else {
        
                            //把吃的总数-1
                            Desk.count--;
                            //如果有，就开吃
                            System.out.println("吃货在吃面条，还能再吃" + Desk.count + "碗");
                            //吃完之后，唤醒厨师继续做
                            Desk.lock.notifyAll();
                            //修改桌子的状态
                            Desk.foodFlag = 0;
                        }
                    }
                }
            }
        }
    }

生产者代码

package com.heima.thread001;
    
    public class CookThread extends Thread {
        
    
        @Override
        public void run() {
        
            while (true){
        
                synchronized (Desk.lock){
        
                    //判断桌子上有没有面条
                    if (Desk.count == 0){
        
                        break;
                    }else {
        
                        //判断桌子上是否有实物
                        if(Desk.foodFlag == 1){
        
                            //如果有，就等待
                            try {
        
                                Desk.lock.wait();
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();
                            }
                        }else {
        
                            //如果没有，就制作面条
                            System.out.println("厨师做了一碗面条");
                            //修改桌子上的食物状态
                            Desk.foodFlag = 1;
                            //叫醒等待的消费者开吃
                            Desk.lock.notifyAll();
                        }
                    }
                }
            }
        }
    }

控制生产者和消费者的执行类

package com.heima.thread001;
    
    public class Desk {
        
    
        /**
         * 作用：控制生产者和消费者的执行
         */
    
        //是否有面条  0：没有面条  1：有面条
        public static int foodFlag = 0;
    
        //总个数
        public static int  count = 10;
    
        //锁对象
        public static Object lock = new Object();
    }

测试类

package com.heima.thread001;
    
    public class TestDemo {
        
        public static void main(String[] args){
        
    
            CookThread cookThread = new CookThread();
            FoodThread foodThread = new FoodThread();
    
            cookThread.setName("厨师");
            foodThread.setName("吃货");
    
            cookThread.start();
            foodThread.start();
        }
    }

运行结果

Connected to the target VM, address: '127.0.0.1:52025', transport: 'socket'
    Disconnected from the target VM, address: '127.0.0.1:52025', transport: 'socket'
    厨师做了一碗面条
    吃货在吃面条，还能再吃9碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃8碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃7碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃6碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃5碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃4碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃3碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃2碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃1碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃0碗
    
    Process finished with exit code 0

[1807410f4d77454f91ba5d7eabf771d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/26/ad87c800c5284b339644685670bdc922.png
[862e5f1640bd4d04983d10c9d954f64e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/26/cf103cdef55a44dab05a568eff503c84.png
[d4bf42e763ae4d19a92d3f4acd00b99a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/26/5bd85ef4b86c41d3b05c9d9f8525fd39.png
[3115b0b9b14243fb9873e06498606cac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/26/ea3dce46f1314eaeb1c0d43a3e41a1ad.png