Java学习记录 Day22（线程）

系统管理员 2022-01-23 11:41 241阅读 0赞

### 文章目录 ###

*  Day 22
 *   *  线程简介
     *  线程创建
     *  线程范例：龟兔赛跑
     *  线程状态
     *  线程方法
     *  线程同步
     *  线程死锁
     *  线程协作——生产者消费者模式
     *  线程池

# Day 22 #

2019年6月2日。  
这是我学习Java的第二十二天。  
这一天，我学到了以下的知识。

## 线程简介 ##

线程，是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。  
在Java中，线程的执行如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]  
说起线程，就必须要说到**程序**。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。  
而**进程**则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。  
通常在一个进程中可以包含若干个**线程**，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。  
线程的性质如下所述：

*  线程就是独立的执行路径；
 *  在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
 *  main（）称之为主线程，为系统的入口，用于执行整个程序；
 *  在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的；
 *  对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
 *  线程会带来额外的开销，如cpu调度时间，并发控制开销。
 *  每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

## 线程创建 ##

线程的创建，在Java中，具有三种方式：

*  **继承Thread类**  
    \- 实现步骤：  
    1.自定义线程类继承Thread类  
    2.重写run（）方法，编写线程执行体  
    3.创建线程对象，调用start（）方法启动线程  
    \- 范例如下：
    
        public class TestThread extends Thread{
        
        //自定义run方法的线程
        @Override
        public void run() {
            //线程执行体
            for (int i = 0; i < 200; i++) {
                System.out.println("a:" + i);
            }
        }
        
        //主线程
        public static void main(String[] args) {
        
            //创建线程对象
            TestThread testThread1 = new TestThread1();
        
            //调用start方法启动线程
            testThread1.start();
        
            //同时进行
            for (int i = 0; i < 3000; i++) {
                System.out.println("b:" + i);
            }
        }
        }
 *  **实现Runnable接口（常用）**  
    \- 实现步骤：  
    1.定义MyRunnable类实现Runnable接口  
    2.实现run（）方法，编写线程执行体  
    3.创建线程对象，调用start（）方法启动线程  
    \- 范例如下：
    
        public class TestThread implements Runnable{
        @Override
        public void run() {
            //线程执行体
            for (int i = 0; i < 200; i++) {
                System.out.println("a:" + i);
            }
        }
        
        public static void main(String[] args) {
            //重点就是将runable接口实现类的对象丢入Thread构造器
            TestThread testThread3 = new TestThread3();
        
            Thread thread = new Thread(testThread3);
        
            thread.start();
        
            for (int i = 0; i < 3000; i++) {
                System.out.println("b:" + i);
            }
        }
        }
 *  **实现Callable接口**  
    \- 实现步骤：  
    1.实现Callable接口，需要返回值类型  
    2.重写call方法，需要抛出异常  
    3.创建目标对象  
    4.创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);  
    5.提交执行：Future<Boolean.> result = ser.submit(t1);  
    6.关闭服务：ser.shutdownNow();  
    \- 范例如下：
    
        public class Demo4Thread implements Callable<Boolean> {
        
        @Override
        public Boolean call() throws Exception {
            return false;
        }
        
        public static void main(String[] args) {
            Demo4Thread demo4Thread = new Demo4Thread();
        
            ExecutorService ser = Executors.newFixedThreadPool(1);
        
            Future<Boolean> result1 = ser.submit(demo4Thread);
        }
        
        }
 *  **继承Thread类和实现Runnable接口的区别**  
    \- 继承Thread类  
    1.子类继承Thread类具备多线程能力  
    2.启动线程：子类对象.start()  
    3.**不建议使用：避免OOP单继承局限性**  
    \- 实现Runnable接口  
    1.实现接口Runnable具有多线程能力  
    2.启动线程：传入目标对象+Thread对象.start()  
    3.**推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用**

## 线程范例：龟兔赛跑 ##

需求：模仿“龟兔赛跑”的故事，在Java中用两个线程来实现

分析：

1.  龟兔赛跑开始
2.  故事中是乌龟赢的，兔子需要睡觉，所以要模拟兔子睡觉
3.  首先定义赛道距离，然后乌龟离赛道终点越来越近
4.  判断比赛是否结束
5.  最终，乌龟赢得比赛
6.  打印出胜利者

代码如下：

public class Race implements Runnable{
    
        //winner:只有一个胜利者
        private static String winner;
    
        @Override
        public void run() {
            //赛道
            for (int step = 1; step <= 101; step++) {
    
                //模拟兔子休眠
                if (Thread.currentThread().getName().equals("兔子") && step % 50 ==0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
                //判断比赛是否结束
                boolean flag = gameOver(step);
                if (flag){
                    break;
                }
               System.out.println( Thread.currentThread().getName() + "跑了" + step +"步");
            }
        }
    
        //判断比赛是否结束
        private boolean gameOver(int step){
            if (winner != null){ // 如果存在胜利者
                return true;
            }
            if (step >= 100){ // 如果跑到了终点
                winner = Thread.currentThread().getName();
                System.out.println("比赛结束");
                System.out.println("胜利者--->" + winner);
                return true;
            }
            return false;
        }
    
        public static void main(String[] args) {
            Race race = new Race();
    
            new Thread(race,"兔子").start();
            new Thread(race,"乌龟").start();
        }
    }

## 线程状态 ##

线程的状态，在Java中，共具有5种，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]  
线程的状态转换，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]

## 线程方法 ##

在Java中，线程类里存在一些特定的方法，可以对线程进行管理，如下所示：

*  线程停止  
    虽然线程类中提供了stop（）方法和destroy（）方法，但是不推荐使用，而是推荐线程自己停止下来。  
    若想要线程自行停止，建议使用一个标志位充当终止变量，当flag=false，则终止线程运行。
 *  线程休眠（sleep）
    
     *  sleep（时间）指定当前线程阻塞的毫秒数；
     *  sleep存在异常InterruptedException；
     *  sleep时间达到后线程进入就绪状态；
     *  sleep可以模拟网络延时，倒计时等‘’
     *  每一个对象都有一个锁，sleep不会释放锁；
    
    用线程休眠来模拟系统时间并且让时间流动，示例如下：

public class TestSleep2 {
        public static void main(String[] args) throws InterruptedException {
    
            TestSleep2 testSleep2 = new TestSleep2();
    
            //获取系统时间
            Date startTime = new Date(System.currentTimeMillis());
    
            while (true) {
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                Thread.sleep(1000);
                startTime = new Date(System.currentTimeMillis());
            }
    
        }
    
        //倒计时方法
        private void tenDown() throws InterruptedException {
            int num = 10;
            for (int i = 10; i > 0; i--) {
                Thread.sleep(1000);
                System.out.println("倒计时:"+i);
            }
    
        }
    }

*  线程礼让（yield）
    
     *  礼让线程，让当前正在执行的线程暂停，但不阻塞；
     *  将线程从运行状态转为就绪状态；
     *  **让cpu重新调度，礼让不一定会成功！**
    
    示例如下：

public class TestYield {
    
        public static void main(String[] args) throws InterruptedException {
            MyYield myYield = new MyYield();
            new Thread(myYield,"小明").start();
            new Thread(myYield,"老师").start();
        }
    }
    
    class MyYield implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"-->启动了");
            Thread.yield();//礼让
            System.out.println(Thread.currentThread().getName()+"-->停止了");
        }
    }

*  线程插队（join）
    
     *  Join可以插入线程，当该线程执行完毕后，再执行其他线程（其他线程之前会阻塞）；
     *  join与现实世界的插队类似；  
        示例如下：

public class TestJoin implements Runnable{
    
        public static void main(String[] args) throws InterruptedException {
            TestJoin testJoin = new TestJoin();
    
            Thread thread = new Thread(testJoin);
            thread.start();
    
            for (int i = 0; i < 100; i++) {
                if (i==80){
                    //强制执行
                    thread.join();
                }
                System.out.println("我是主线程:"+i);
            }
    
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("我是要插队的线程:"+i);
            }
        }
    }

*  线程状态观测（State）  
    通过Thread.State（）方法，可以查看线程当前的状态。  
    线程的状态，有以下几种：
    
     *  NEW  
        尚未启动的线程处于此状态
     *  RUNNABLE  
        在Java虚拟机中执行的线程处于此状态
     *  BLOCKED  
        被阻塞等待监视器锁定的线程处于此状态
     *  WAITING  
        正在等待另一个线程执行特定动作的线程处于此状态
     *  TIMED WAITING  
        正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
     *  TERMINATED  
        已退出的线程处于此状态
    
    一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程状态的虚拟机状态  
    实例如下：

public class TestState {
        public static void main(String[] args) throws InterruptedException {
    
            Thread thread = new Thread(()->{
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getState());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }

*  线程优先级（priority）
    
     *  Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
     *  线程的优先级用数字表示，范围从1~10
        
         *  Thread.MIN\_PRIORITY = 1;
         *  Thread.MAX\_PRIORITY = 10;
         *  Thread.NORM\_PRIORITY = 5;
     *  使用这些方式可以改变（setPriority）或者获取优先级（getPriority）  
        示例如下：

public class TestPriority {
    
        public static void main(String[] args) {
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    
    
            MyPriority myPriority = new MyPriority();
            Thread thread1 = new Thread(myPriority);
            Thread thread2 = new Thread(myPriority);
            Thread thread3 = new Thread(myPriority);
            Thread thread4 = new Thread(myPriority);
            Thread thread5 = new Thread(myPriority);
    
    
            thread1.setPriority(1);
            thread1.start();
    
            thread2.setPriority(4);
            thread2.start();
    
            thread3.setPriority(8);
            thread3.start();
    
            thread4.setPriority(9);
            thread4.start();
    
            thread5.setPriority(10);
            thread5.start();
    
        }
        
    }
    
    class MyPriority implements Runnable{
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        }
    }

*  守护线程（daemon）
    
     *  线程分为**用户线程**和**守护线程**；
     *  虚拟机必须确保用户线程执行完毕；
     *  虚拟机不用等待守护线程执行完毕
     *  守护进程一般用作后台记录操作日志、监控内存、以及垃圾回收等待
    
    示例如下：

public class TestDaemon {
        public static void main(String[] args) {
            God god = new God();
            Thread thread = new Thread(god);
            thread.setDaemon(true); //设置线程为守护线程,默认为false
            thread.start();
    
            //用户线程
            new Thread(()->{
                for (int i = 0; i < 30; i++) {
                    System.out.println("你开心的在这个世界上活着"+i);
                }
                System.out.println("=======Goodbye , World!");
            }).start();
        }
    }
    
    //守护线程
    class God implements Runnable{
        @Override
        public void run() {
            for (;true;){
                System.out.println("上帝保佑着你");
            }
        }
    }

## 线程同步 ##

若多个线程操作同一个资源，可能会出现线程不安全的情况。

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步实质上就是一种等待机制，多个需要同时访问此对象的线程进入这个**对象的等待池**形成队列，等待前面线程使用完毕，下一个线程再使用。

由于同一个进程的多个线程共享同一块存储空间，为了保证数据在方法中被访问时的正确性，在访问时加入**锁机制synchronized**，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。该机制会带来以下问题：

*  一个线程持有锁会导致其他所有需要此锁的线程挂起；
 *  在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
 *  如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致**优先级倒置**，引起性能问题。

**同步方法**（并发问题一）

*  由于可以通过private关键字来保证数据对象只能被方法访问，所以只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块  
    同步方法:`public synchronized void method(int args){}`
 *  synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，并继续执行（**缺陷：若将一个大的方法申明为synchronized，将会影响效率**）

假设同时有三个人在买票，票数总共有10张，若不添加同步关键字，则会出现线程不安全的问题（即会出现一张票被同时买到的情况）示例如下：  
1.不安全情况

public class UnsafeBuyTicket implements Runnable {
    
        //票数
        private int ticketNums = 10;
        //标志位
        private boolean flag = true;
    
    
        @Override
        public void run() {
            //买票
            while (flag) {
                buyTicket();
            }
        }
    
        public void buyTicket() {
            if (ticketNums <= 0) {
                flag = false;
                return;
            }
    
            //模拟网络延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "张票");
        }
    
    
        public static void main(String[] args) {
            UnsafeBuyTicket station = new UnsafeBuyTicket();
    
            new Thread(station,"苦逼的我").start();
            new Thread(station,"牛逼的你们").start();
            new Thread(station,"可恶的黄牛党").start();
    
        }
    
    }

2.安全情况（加入同步方法）

public class SafeBuyTicket implements Runnable {
    
        //票数
        private int ticketNums = 10;
        //标志位
        private boolean flag = true;
    
        @Override
        public void run() {
            //买票
            while (flag) {
                buyTicket();
            }
        }
    
        //同步方法,关键词synchroinzed.
    
        //关键字是锁
        //实现的机制是队列
    
        //还能所反射的那个class
    
        public synchronized void buyTicket() {
            if (ticketNums <= 0) {
                flag = false;
                return;
            }
    
            //模拟网络延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "张票");
        }
    
    
        public static void main(String[] args) {
            SafeBuyTicket station = new SafeBuyTicket();
    
            new Thread(station,"苦逼的我").start();
            new Thread(station,"牛逼的你们").start();
            new Thread(station,"可恶的黄牛党").start();
    
        }
    }

**同步块**（并发问题二）

*  格式：`synchronized(Obj obj){}`，Obj称之为**同步监视器**  
    \- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器  
    \- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
 *  同步监视的执行过程  
    \- 第一个线程访问，锁定同步监视器，执行其中代码；  
    \- 第二个线程访问，发现同步监视器被锁定，无法访问；  
    \- 第一个线程访问完毕，解锁同步监视器；  
    \- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

假设同时有两个人在银行取钱，若不添加同步关键字，则会出现线程不安全的问题（即会出现第一个人把存款取完，在银行存款还没有及时刷新时，第二个人再次取款，则会让银行存款变为负数）示例如下：  
1.不安全情况

public class UnsafeBank {
        public static void main(String[] args) {
            Account account = new Account(100,"招商卡");
    
            Bank you = new Bank("痛苦的你",account,50);
            Bank wife = new Bank("开心的媳妇",account,100);
    
            you.start();
            wife.start();
        }
    }
    
    
    //账户
    class Account{
        int money;//余额
        String name; //卡名
    
        public Account(int money, String name) {
            this.money = money;
            this.name = name;
        }
    }
    
    
    //银行
    class Bank extends Thread{
        //存钱:存了多少,取钱:取了多少
    
        Account account;  //账户
        int drawingMoney; //取了多少钱
        int nowMoney; //手里有多少钱
    
        public Bank(String name,Account account,int drawingMoney){
            super(name);
            this.account = account;
            this.drawingMoney = drawingMoney;
        }
    
        @Override
        public void run() {
    
            //判断能否取钱
            if (account.money-drawingMoney<0){
                return;
            }
    
            //为了放大问题发生性,我们加个延时.
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //余额 = 余额 - 你去走的钱
            account.money = account.money - drawingMoney;
            //你的钱 = 你的钱 + 你取的钱
            nowMoney = drawingMoney + nowMoney;
    
            System.out.println(this.account.name+"账户余额:"+account.money);
            System.out.println(this.getName()+"手里的钱:"+nowMoney);
    
    
        }
    }

2.安全情况（同步块）

public class SafeBank {
    
    
        public static void main(String[] args) {
            Account2 account = new Account2(100,"招商卡");
    
            Bank2 you = new Bank2("痛苦的你",account,50);
            Bank2 wife = new Bank2("开心的媳妇",account,100);
    
            you.start();
            wife.start();
        }
    }
    
    //账户
    //实体类
    class Account2{
        int money;//余额
        String name; //卡名
    
        public Account2(int money, String name) {
            this.money = money;
            this.name = name;
        }
    }
    
    
    //银行
    class Bank2 extends Thread{
        //存钱:存了多少,取钱:取了多少
    
        Account2 account;  //账户
        int drawingMoney; //取了多少钱
        int nowMoney; //手里有多少钱
    
        public Bank2(String name,Account2 account,int drawingMoney){
            super(name);
            this.account = account;
            this.drawingMoney = drawingMoney;
        }
    
        @Override
        public void run() {
            drwaing();
        }
    
        //synchronized本身锁的是this.就是这个对象本身
        public void drwaing(){
    
            //提高性能的代码
            if (account.money<=0){
                return;
            }
    
            //如何判断锁的对象
            // 谁需要实现增删改就去锁定他
            synchronized (account){
    
                //判断能否取钱
                if (account.money-drawingMoney<0){
                    System.out.println(Thread.currentThread().getName()+"活该,没取到钱");
                    return;
                }
    
                //为了放大问题发生性,我们加个延时.
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                //余额 = 余额 - 你去走的钱
                account.money = account.money - drawingMoney;
                //你的钱 = 你的钱 + 你取的钱
                nowMoney = drawingMoney + nowMoney;
    
                System.out.println(this.account.name+"账户余额:"+account.money);
                System.out.println(this.getName()+"手里的钱:"+nowMoney);
            }
    
        }
    }

**List**（并发问题三）

因为List并非是线程安全的，所以同样需要用synchronized来令List线程的线程安全。  
示例如下：  
1.不安全情况

public class UnSafeList {
        public static void main(String[] args) throws InterruptedException {
            List<String> list = new ArrayList<String>();
    
            for (int i = 0; i < 20000; i++) {
                new Thread(()->{
                    list.add(Thread.currentThread().getName());
                }).start();
            }
    
            for (int i = 5;i>0;i--){
                Thread.sleep(1000);
                System.out.println("倒计时"+i);
            }
    
            System.out.println(list.size());
    
        }
    }

2.安全情况（同步关键字）

public class SafeList {
        public static void main(String[] args) throws InterruptedException {
    
            List<String> list = new ArrayList<String>();
    
            for (int i = 0; i < 10000; i++) {
                new Thread(()->{
                    synchronized (list){
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
            }
    
            for (int i = 5;i>0;i--){
                Thread.sleep(1000);
                System.out.println("倒计时"+i);
            }
    
            System.out.println(list.size());
    
        }
    }

## 线程死锁 ##

*  概念：多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行。而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“**两个以上对象的锁**”时，就可能发生“死锁”的问题
 *  产生死锁的必要条件：  
    \- 互斥条件：一个资源每次只能被一个进程使用  
    \- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放  
    \- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺  
    \- 循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系

**解决死锁**

上面列出的死锁的四个必要条件，只要想办法破坏其中的任意一个或多个条件，就可以避免死锁发生

假设有两个女生，在出门之前同时进行化妆（需要拿镜子和口红），若一个女生先拿到镜子，另一个女生先拿到口红，之后，为了得到彼此的口红和镜子，两方都需要等待，就会发生死锁，示例如下：  
1.不安全情况

public class DeadLocked {
    
        public static void main(String[] args) {
            Makeup g1 = new Makeup(0,"白雪公主");
            Makeup g2 = new Makeup(1,"灰姑凉");
    
            new Thread(g1).start();
            new Thread(g2).start();
    
        }
    
    }
    
    //化妆
    class Makeup implements Runnable{
    
        //选择
        int choice;
        //谁进来了
        String girlName;
    
        //两个对象
        static LipStick lipStick = new LipStick();
        static Mirror mirror = new Mirror();
    
        public Makeup(int choice,String girlName){
            this.choice = choice;
            this.girlName = girlName;
        }
    
        @Override
        public void run() {
            //化妆
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        //化妆的方法
        public void makeup() throws InterruptedException {
            if (choice==0){ //先拿口红,再拿镜子
                synchronized (lipStick){
                    System.out.println("拿到口红");
                    Thread.sleep(1000);
                    //等待拿镜子的人释放锁
                    synchronized (mirror){
                        System.out.println("拿到镜子");
                    }
                }
    
            }else { //先拿镜子 , 再拿口红
                synchronized (mirror){
                    System.out.println("拿到镜子");
                    Thread.sleep(2000);
                    //等待拿口红的人释放锁
                    synchronized (lipStick){
                        System.out.println("拿到口红");
                    }
                }
            }
    
        }
    
    }

2.安全情况（避免synchronized块嵌套）

public class DeadLocked {
    
        public static void main(String[] args) {
            Makeup g1 = new Makeup(0,"白雪公主");
            Makeup g2 = new Makeup(1,"灰姑凉");
    
            new Thread(g1).start();
            new Thread(g2).start();
    
        }
    
    }
    
    //化妆
    class Makeup implements Runnable{
    
        //选择
        int choice;
        //谁进来了
        String girlName;
    
        //两个对象
        static LipStick lipStick = new LipStick();
        static Mirror mirror = new Mirror();
    
        public Makeup(int choice,String girlName){
            this.choice = choice;
            this.girlName = girlName;
        }
    
        @Override
        public void run() {
            //化妆
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        //化妆的方法
        public void makeup() throws InterruptedException {
            if (choice==0){ //先拿口红,再拿镜子
                synchronized (lipStick){
                    System.out.println("拿到口红");
                    Thread.sleep(1000);
                    //等待拿镜子的人释放锁
                }
                synchronized (mirror){
                    System.out.println("拿到镜子");
                }
    
            }else { //先拿镜子 , 再拿口红
                synchronized (mirror){
                    System.out.println("拿到镜子");
                    Thread.sleep(2000);
                    //等待拿口红的人释放锁
                }
                synchronized (lipStick){
                    System.out.println("拿到口红");
                }
            }
    
        }
    
    }
    
    
    
    
    
    //口红
    class LipStick{
    
    }
    
    //镜子
    class Mirror{
    
    }

**Lock（锁）**

*  从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
 *  java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
 *  ReentranLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

示例如下：

public class TestLock {
        public static void main(String[] args) {
            HelloWorld helloWorld = new HelloWorld();
    
            new Thread(helloWorld).start();
            new Thread(helloWorld).start();
    
        }
    }
    
    
    class HelloWorld implements Runnable{
    
        int ticketNums = 100;
        //可重入锁
        private final ReentrantLock lock = new ReentrantLock();
    
        @Override
        public void run() {
            while (true){
    
                try {
                    lock.lock(); //加锁
                    //判断是否有票
                    if (ticketNums>0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(ticketNums--);
                    }else {
                        break;
                    }
                } finally {
                    lock.unlock();//解锁
                }
    
            }
    
        }
    
    }

**synchronized 与 Lock 的对比**

*  Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
 *  Lock只有代码块锁，synchronized有代码块锁和方法锁
 *  使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
 *  优先使用顺序：  
    \- Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

## 线程协作——生产者消费者模式 ##

*  **应用场景**：生产者和消费者问题  
    \- 假设仓库只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费  
    \- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止  
    \- 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止
 *  **分析**：**这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件**  
    \- 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费  
    \- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费  
    \- 在生产者消费者问题中，仅有synchronized是不够的：  
    1.synchronized可阻止并发更新同一个共享资源，实现了同步  
    2.但synchronized不能用来实现不同线程之间的消息传递（通信）
 *  **线程方法**：针对线程之间互相通信的问题，Java提供了几个方法用于解决  
    \- `wait()`：表示线程一直等待，直到其他线程通知，与sleep不同，**会释放锁**  
    \- `wait(long timeout)`：指定等待的毫秒数  
    \- `notify()`：唤醒一个处于等待状态的线程  
    \- `notifyall()`：唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度  
    **注意：以上的均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegaIMonitorStateException**

**解决方式**：针对生产者/消费者模式的问题，有两种方法可以解决

*  管程法  
    \- 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）；  
    \- 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）；  
    \- 缓冲区：消费者不能直接使用生产者的数据，它们之间有一个缓冲区  
    **生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据**  
    示例如下：

//思路
    
    //1.思考需要哪些对象?
    // 生产 , 消费 , 产品 , 容器
    
    //2.分工
    
    /*
        生产者只管生产
        消费者只管消费
        鸡: 实体类
    
        容器 :
    
        容器添加数据.
        要判断容器是否满 , 满了等待消费者消费
        没有满,通知生产者生产
    
        容器减少数据
        判断还有没有数据, 没有数据的话 . 等待生产者生产
        消费完毕 , 通知生产者生产
     */
    
    
    import java.sql.SQLOutput;
    
    //测试生产者和消费者问题
    public class TestPC {
        public static void main(String[] args) {
            SynContainer synContainer = new SynContainer();
    
            new Productor(synContainer).start();
            new Consumer(synContainer).start();
        }
    }
    
    
    //生产者
    class Productor extends Thread{
        //需要向容器中加入产品
        SynContainer container;
        public Productor(SynContainer container){
            this.container = container;
            }
            @Override
            public void run() {
                for (int i = 1; i < 100; i++) {
                    //生产者添加产品
                container.push(new Chicken(i));
                System.out.println("生产者生产了"+i+"鸡");
            }
        }
    }
    
    //消费者
    class Consumer extends Thread{
        SynContainer container;
        public Consumer(SynContainer container){
            this.container = container;
        }
        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                //消费者拿走产品
                Chicken chicken = container.pop();
                System.out.println("消费者消费了"+chicken.id+"鸡");
            }
        }
    }
    
    
    //缓冲区-->容器
    class SynContainer{
    
        //容器
        Chicken[] chickens = new Chicken[10];
    
    
    
        //容器的计数器
        int num = 0;
    
        //生产者放入产品
        public synchronized void push(Chicken chicken) {
    
            //假如容易已经满了,就不用放,等待消费者消费
            if (num>=chickens.length){
    
                //等待消费者消费
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
            //假如容器没有满 , 通知生产生成
    
            System.out.println("num,,,,,"+num);
            chickens[num] = chicken;
            System.out.println("数组有多少个元素"+num);
            num++;
            //通知消费者消费
            this.notifyAll();
    
        }
    
        //消费者拿走产品
        public synchronized Chicken pop(){
            //假如容器空的,等待
            if (num<=0){
                //等待生产
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
            num--;
            Chicken chicken = chickens[num];
            //通知生产者生产
            this.notifyAll();
            return chicken;
        }
    
    
    }
    
    //产品->鸡
    class Chicken {
        int id;
    
        public Chicken(int id) {
            this.id = id;
        }
    }

*  信号灯法  
    在产品中设置一个标志位，利用标志位（flag）来选择让生产者执行逻辑还是让消费者执行逻辑（类似于红灯停，绿灯行）
    
    示例如下：

//生产者消费2
    //生产者--->演员
    //消费者--->观众
    //产品:信号灯--->电视----->声音
    
    public class TestPC2 {
        public static void main(String[] args) {
            TV tv = new TV();
    
            new Player(tv).start();
            new Watcher(tv).start();
        }
    }
    
    
    //生产者
    class Player extends Thread{
        TV tv;
    
        public Player(TV tv){
            this.tv = tv;
        }
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                if (i%2==0){
                    this.tv.play("节目:快乐大本营播放中");
                    System.out.println();
                }else {
                    this.tv.play("广告:抖音,记录美好生活");
                }
            }
        }
    }
    
    //消费者
    class Watcher extends Thread{
        TV tv;
        public Watcher(TV tv){
            this.tv = tv;
        }
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                tv.watch();
            }
        }
    }
    
    //电视
    class TV{
        //演员说话 , 观众等待
        //观众观看 , 演员等待
        boolean flag = true;
    
        //说话
        String voice;
    
        //表演
        public synchronized void play(String voice){
    
            //演员等待
            if (!flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            System.out.println("表演了"+voice);
            this.voice = voice;
    
            //让观众观看
            this.notifyAll();
            this.flag = !this.flag;
    
        }
    
    
        //观看
        public synchronized void watch(){
    
    
            //观众等待
            if (flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            System.out.println("观众听到了: "+voice);
    
            //通知演员说话
            this.notifyAll();
    
            this.flag = !this.flag;
        }
    
    }

## 线程池 ##

*  背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
 *  思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
 *  好处：  
    \- 提高响应速度（减少了创建新线程的时间）  
    \- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）  
    \- 便于线程管理
 *  定义：  
    \- corePoolSize：核心池的大小  
    \- maximumPoolSize：最大线程数  
    \- keepAliveTime：线程没有任务时最多保持多长时间后终止
 *  使用线程池：JDK 5.0起提供了线程池相关API：**ExecutorService**和**Executors**  
    \- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor  
    \- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable  
    \- <T.>Future<T.> submit(Callable<T.> task)：执行任务，有返回值，一般用来执行Callable  
    \- void shutdown()：关闭线程池  
    \- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

示例：

public class ThreadPool{
    
        public static void main(String[] args) {
    
            //创建一个线程池(池子大小)
            ExecutorService pool = Executors.newFixedThreadPool(10);
    
            //执行runnable接口实现类
            pool.execute(new MyThread4());
            pool.execute(new MyThread4());
            pool.execute(new MyThread4());
            pool.execute(new MyThread4());
    
            //关闭连接池
            pool.shutdown();
    
        }
    
    }
    
    class MyThread4 implements Runnable{
        @Override
        public void run() {
            System.out.println("MyThread4");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]: /images/20220123/9d5f73c837664b4d9e7809efc763ee6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]: /images/20220123/81288f516b104911a4cafcc62a5c161b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]: /images/20220123/5e3d54727b0648bf8f42912c28afa129.png