2021-07-31

1.解决线程安全问题Lock锁

package cn.itcast.day04.demo01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
卖票案例：出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的三种方案：lock锁
java.util.concurrent.locks.lock接口
lock实现提供了比使用synchronized方法和语句可获得更广泛的锁定操作。
lock接口中的方法：
   void lock() 获取锁
   void unlocke() 释放锁
   java.util.concurrent.locks.Reentrantlock implements lock接口

   使用步骤：
   1.在成员位置创建一个reentrantlock对象
   2.在可能会出现安全问题的代码前调用lock接口中的方法lock获取锁
   3.在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁
 }
*/
public class RunnableImpl implements Runnable {
    //定义一个多线程共享的票源
    private static int tacket = 100;

    //1.在成员位置创建一个Reentrantlock对象
    Lock l = new ReentrantLock();


    //设置线程任务：卖票
/*    @Override
    public void run() {
        //先判断票是否存在
        while (true) {

            //2.在可能会出现安全问题的代码前调用lock接口中的方法lock获取锁
            l.lock();
            if (tacket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，卖票 tacket --
                System.out.println(Thread.currentThread().getName() + "--->在卖第" + tacket + "张票！");
                tacket--;
            }

            //3.在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁
            l.unlock();
        }
    }*/


    public void run() {
        //先判断票是否存在
        while (true) {

            //2.在可能会出现安全问题的代码前调用lock接口中的方法lock获取锁
            l.lock();
            if (tacket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                    //票存在，卖票 tacket --
                    System.out.println(Thread.currentThread().getName() + "--->在卖第" + tacket + "张票！");
                    tacket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //3.在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁
                    l.unlock();//好处：无论程序是否异常，代码都会把锁释放，程序的运行效率会更高
                }

            }
        }
    }
}

2.线程状态

3.等待唤醒案例分析

4.等待唤醒案例代码实现

package cn.itcast.day04.demo01;

/*
等待唤醒案例：线程之间的通信
   创建一个顾客线程（消费者）：告诉老板要的包子的种类和数量，调用wait方法，放弃cpu的执行权，进入到WAITING状态(无限等待)
   创建一个老板线程（生产者）：花了5s做包子，做好包子调用notify方法，唤醒顾客吃包子
 注意：
   顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
   同步使用的锁对象必须是唯一的
   只有锁对象才能调用wait和notify方法

 Object类中的方法：
 void wait（）
        在其他线程调用此线程的notify（）方法或者notifyall（）方法的，导致当前线程等待；
 void notify（）
        唤醒在此对象监听器上等待的单个线程；
        会继续执行wait方法后的代码；
 */

public class DemoWaitAndNotify {

    public static void main(String[] args) {
        //创建一个锁对象，保证唯一
        Object obj = new Object();

        //创建一个顾客线程（消费者）
        new Thread() {
            @Override
            public void run() {
                //一直在等着买包子
                while (true) {
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术；
                    synchronized (obj) {
                        System.out.println("告诉老板要的包子的种类和数量");

                        //调用wait方法，放弃cpu的执行权，进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子做好了，开吃");
                        System.out.println("--------------------------");
                    }
                }
            }
        }.start();

        //创建一个老板线程（生产者）
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    花了5s做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术；
                    synchronized (obj) {
                        System.out.println("老板5秒钟之后做好了包子，告诉顾客，可以吃包子了");
                        obj.notify();
                    }
                }

            }
        }.start();
    }
}

5.Object类中wait带参方法和notifyAll方法

package cn.itcast.day04.demo01;
/*
进入到TimeWait(计时等待)有两种方式
1.使用sleep（long m）方法，在毫秒值结束之后，线程唤醒进入到Runnable/Blocked状态
2.使用wait（long m）方法，wait方法如果在毫秒值，结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

唤醒方法：
 void notify()唤醒在此对象监视器上等待的单个线程
 void notifyall()唤醒在此对象监视器上等待的所有线程
 */

public class Demo02WaitAndNotify {
    public static void main(String[] args) {
        //创建一个锁对象，保证唯一
        Object obj = new Object();

        //创建一个顾客线程（消费者）
        new Thread() {
            @Override
            public void run() {
                //一直在等着买包子
                while (true) {
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术；
                    synchronized (obj) {
                        System.out.println("顾客1，告诉老板要的包子的种类和数量");

                        //调用wait方法，放弃cpu的执行权，进入到WAITING状态(无限等待)
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子做好了，顾客1开吃");
                        System.out.println("--------------------------");
                    }
                }
            }
        }.start();


        //创建一个顾客线程（消费者）
        new Thread() {
            @Override
            public void run() {
                //一直在等着买包子
                while (true) {
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术；
                    synchronized (obj) {
                        System.out.println("顾客2，告诉老板要的包子的种类和数量");

                        //调用wait方法，放弃cpu的执行权，进入到WAITING状态(无限等待)
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子做好了，顾客2开吃");
                        System.out.println("--------------------------");
                    }
                }
            }
        }.start();


        //创建一个老板线程（生产者）
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    花了5s做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术；
                    synchronized (obj) {
                        System.out.println("老板5秒钟之后做好了包子，告诉顾客，可以吃包子了");
                        obj.notify();//如果有多个等待线程，随机唤醒一个
                        obj.notifyAll();//如果有多个等待线程，唤醒所有等待的线程
                    }
                }

            }
        }.start();
    }
}