超详细Java多线程学习笔记

朱雀 2022-10-13 12:33 301阅读 0赞

### 目录 ###

*   *  1、Thread（重点）
     *  2、Runnable（重点）
     *  3、初识并发问题
     *  4、实现Callable接口（了解即可）
     *  5、静态代理
     *  六、Lamda表达式
     *  七、线程状态
     *  八、停止线程
     *  九、线程休眠
     *  十、线程礼让
     *  十一、Join
     *  十二、线程状态观测
     *  十三、线程的优先级
     *  十四、守护（daemon）线程
     *  十五、线程同步
     *  十六、死锁
     *  十七、Lock(锁)
     *  十八、 线程通信
     *  十九、使用线程池
     *  二十、总结

## 1、Thread（重点） ##

1.  自定义线程类继承Thread类
2.  重写==run()==方法，编写线程执行体
3.  创建线程对象，调用==start()==方法启动线程

代码示例：

package testthread1;
    
    /** * * 创建线程方式一：继承Thread类，重新run()方法，电泳start开启线程 */
    public class TestThread1 extends Thread{ 
    
       public void run()
        { 
            //run方法线程体
            for(int i = 0; i < 10; i++)
                System.out.println("我在看代码——————"+ i);
        }
       
        public static void main(String[] args) { 
           //main线程， 主线程
           
           //创建一个线程对象
           TestThread1 testThread1 = new TestThread1();
           //调用start()方法开启线程
           testThread1.start();
           
           for(int i = 0; i < 10; i++)
           { 
               System.out.println("我在学习多线程——————" + i);
           }
        }
        
    }

结果：

> run:  
> 我在学习多线程——————0  
> 我在学习多线程——————1  
> 我在学习多线程——————2  
> 我在学习多线程——————3  
> 我在看代码——————0  
> 我在看代码——————1  
> 我在看代码——————2  
> 我在看代码——————3  
> 我在学习多线程——————4  
> 我在学习多线程——————5  
> 我在学习多线程——————6  
> 我在学习多线程——————7  
> 我在学习多线程——————8  
> 我在学习多线程——————9  
> 我在看代码——————4  
> 我在看代码——————5  
> 我在看代码——————6  
> 我在看代码——————7  
> 我在看代码——————8  
> 我在看代码——————9  
> 成功构建 (总时间: 0 秒)

可以看到两个线程同时进行。

**注意：线程不一定执行，CPU安排调度**上面的程序每次执行结果可能都不相同，若运行后没有出现类似情况，可以将i的循环调制2000次，此时结果比较明显。

## 2、Runnable（重点） ##

1.  定义MyRunnable类实现Runnable接口
2.  实现run() 方法，编写线程执行体
3.  创建线程对象，调用start() 方法启动线程

代码示例：

//创建线程方法2：实现runnable接口，重写run方法,执行线程需要丢入runnable接口实现类，调用start方法
    public class TestThread3 implements Runnable{ 
        @Override
        public void run(){ 
            //run方法线程体
            for(int i = 0; i < 20; i++)
                System.out.println("我在看代码————" + i);
        }
    
        public static void main(String[] args){ 
            //创建runnable接口实现类对象
            TestThread3 testThread3 = new TestThread3();
    
            //创建线程对象，通过线程对象来开启我们的线程代理
            //Thread thread = new Thread(testThread3);
            //thread.start();
            new Thread(testThread3).start();
    
            for(int i = 0; i < 20; i++){ 
                System.out.println("我在学习多线程—————" + i);
            }
        }
    }

结果：

> 我在学习多线程—————0  
> 我在学习多线程—————1  
> 我在看代码————0  
> 我在看代码————1  
> 我在看代码————2  
> 我在看代码————3  
> 我在看代码————4  
> 我在看代码————5  
> 我在看代码————6  
> 我在看代码————7  
> 我在看代码————8  
> 我在看代码————9  
> 我在学习多线程—————2  
> 我在学习多线程—————3  
> 我在学习多线程—————4  
> 我在学习多线程—————5  
> 我在学习多线程—————6  
> 我在学习多线程—————7  
> 我在学习多线程—————8  
> 我在学习多线程—————9

总结：

继承Thread类

> 子类继承Thread类具备多线程能力  
> 启动线程：子类对象.start()  
> 不建议使用：避免OOP单继承局限性

实现Runnable接口

> 实现接口Runnable具有多线程能力  
> 启动线程：传入目标对象+ Thread对象.start()  
> 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

## 3、初识并发问题 ##

代码示例：

//多个线程同时操作同一个对象
    //买火车票的例子
    
    //发现问题：多个线程操作同一个资源的情况下，线程不安全，数据混乱
    public class TestThread4 implements Runnable{ 
    
        private  int tickNums = 10;
    
        @Override
        public void run(){ 
            while(true){ 
                if(tickNums <= 1){ 
                    break;
                }
               try{ 
                    Thread.sleep(200);
               }catch (InterruptedException e){ 
                    e.printStackTrace();
               }
                System.out.println(Thread.currentThread().getName() + "-->拿到了第" + tickNums-- + "票");
            }
        }
        public static void main(String[] args) { 
    
            TestThread4 ticket = new TestThread4();
    
    
            new Thread(ticket,"小明").start();
            new Thread(ticket,"小红").start();
            new Thread(ticket,"黄牛").start();
    
    
        }
    }

结果：

> 黄牛–>拿到了第10票  
> 小明–>拿到了第8票  
> 小红–>拿到了第9票  
> 小红–>拿到了第6票  
> 黄牛–>拿到了第5票  
> 小明–>拿到了第7票  
> 小明–>拿到了第4票  
> 小红–>拿到了第4票  
> 黄牛–>拿到了第4票  
> 小明–>拿到了第2票  
> 小红–>拿到了第1票  
> 黄牛–>拿到了第3票

练习：[多线程龟兔赛跑][Link 1]

## 4、实现Callable接口（了解即可） ##

1.  实现Callable接口，需要返回值类型
2.  重写call方法，需要抛出异常
3.  创建目标对象
4.  创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5.  提交执行: Future result 1 = ser.submit(t1);
6.  获取结果: boolean r1 = result1.get()
7.  关闭服务: ser.shutdownNow();

## 5、静态代理 ##

需求：

> 你：真实角色  
> 婚庆公司：代理你，帮你处理结婚的事  
> 结婚：实现都实现结婚接口即可

代码示例：

/*静态代理模式总结： 真实对象和代理对象都要实现同一个接口 代理对象要代理真实角色 好处：代理对象可以做很多真实对象做不了的事情 真实对象专注做自己的事情 */
    public class StaticProxy { 
        public static void main(String[] args) { 
    
            new Thread( ()-> System.out.println("我爱你") ).start();
            new weddingCompany(new You()).HappyMarry();
    // You you = new You(); //你要结婚
    //
    // weddingCompany weddingCompany = new weddingCompany(you);
    // weddingCompany.HappyMarry();
        }
    }
    
    interface  Marry{ 
    
        void HappyMarry();
    }
    
    //真实角色，你去结婚
    class You implements Marry{ 
        @Override
        public void HappyMarry(){ 
            System.out.println("张三要结婚了");
        }
    }
    
    //代理角色，帮助你结婚
    class weddingCompany implements Marry{ 
        //代理谁-->真实目标角色
        private Marry target;
    
        public weddingCompany(Marry target){ 
            this.target = target;
        }
    
        @Override
        public void HappyMarry(){ 
            before();
            this.target.HappyMarry();  //这就是真实角色
            after();
            
        }
        private void after(){ 
            System.out.println("结婚之后，收尾款");
        }
        private void before(){ 
            System.out.println("结婚之前，布置现场");
        }
    
    }

[图解设计模式------Proxy（代理）模式][------Proxy]

## 六、Lamda表达式 ##

6.1 为什么要使用lamda表达式？

*  避免匿名内部类定义过多
 *  可以让你的代码看起来很简洁
 *  去掉了一堆没有意义的代码，只留下核心的逻辑

理解Runctional interface（函数式接口）是学习Java8 lamda表达式的关键所在。

函数式接口的定义：

1.  任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
2.  对于代码，我们可以通过lamda表达式来创建该接口的对象

代码简化过程：

package Lambda;
    
    
    //推到lambda表达式
    public class TestLambda1 { 
    
        //3、静态内部类
        static class Like2 implements ILike{ 
            @Override
            public void lambda(){ 
                System.out.println("I like lambda2");
            }
        }
    
        public static void main(String[] args) { 
            ILike like = new Like();
            like.lambda();
    
            like = new Like2();
            like.lambda();
    
            //4、局部内部类
            class Like3 implements ILike{ 
                @Override
                public void lambda(){ 
                    System.out.println("I like lambda3");
                }
            }
            like = new Like3();
            like.lambda();
    
            //5、匿名内部类,没有类的名称，必须借助接口或父类
            like = new ILike() { 
                @Override
                public void lambda() { 
                    System.out.println("I like lambda4");
                }
            };
            like.lambda();
    
            //6、用lambda简化
            like = ()->{ 
                System.out.println("I like lambda5");
            };
            like.lambda();
    
        }
    }
    
    //1、定义一个函数式接口
    interface ILike{ 
        void lambda();
    }
    
    //2、实现类
    class Like implements ILike{ 
        @Override
        public void lambda(){ 
            System.out.println("I like lambda");
        }
    }

package Lambda;
    
    public class TestLamda2 { 
        public static void main(String[] args) { 
    
            Ilove love = null;
           // 1.lambda表达式
           love = (int a) -> { 
                System.out.println("I Love You--->" + a);
            };
            love.love(520);
    
            //简化1.参数类型
            love = (a) -> { 
                System.out.println("I Love You--->" + a);
            };
            love.love(521);
    
            //简化2.简化括号
            love = a -> { 
                System.out.println("I Love You--->" + a);
            };
            love.love(522);
    
    
            //简化3.简化花括号
            love = a -> System.out.println("I Love You--->" + a);
            love.love(523);
    
            /* 总结： 1、lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，那么就用代码块包裹； 2、前提是接口为函数式接口 3、多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号 */
    
    
        }
    }
    
    interface Ilove{ 
        void love(int a);
    }

## 七、线程状态 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center]  
**线程方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>setPriority(int newPriority)</td> 
   <td>更改线程的优先级</td> 
  </tr> 
  <tr> 
   <td>static void sleep(long millis)</td> 
   <td>在指定的毫秒数内让正在执行的线程休眠</td> 
  </tr> 
  <tr> 
   <td>void join()</td> 
   <td>等待该线程终止</td> 
  </tr> 
  <tr> 
   <td>static void yield()</td> 
   <td>暂停当前正在执行的线程对象，并执行其他线程</td> 
  </tr> 
  <tr> 
   <td>void interrupt()</td> 
   <td>中断线程，别用这个方法</td> 
  </tr> 
  <tr> 
   <td>boolean isAlive()</td> 
   <td>测试线程是否处于活动状态</td> 
  </tr> 
 </tbody> 
</table>

## 八、停止线程 ##

*  不推荐使用JDK提供的stop()、destroy()方法
 *  推荐线程自己停下来
 *  建议使用一个标志位进行终止变量，如当flag = false，则终止线程运行

//测试stop
    //1、建议线程正常停止---->利用次数，不建议死循环
    //2、建议使用标志位
    
    
    public class TestStop implements Runnable{ 
    
        //1、设置一个标志位
        private boolean flag = true;
    
        @Override
        public void run(){ 
            int i = 0;
            while(flag){ 
                System.out.println("run....Thread" + i++);
            }
        }
    
        //2、设置一个公开的方法停止线程，转换标志位
        public void stop(){ 
            this.flag = false;
        }
    
        public static void main(String[] args) { 
            TestStop testStop = new TestStop();
            new Thread(testStop).start();
    
            for (int i = 0; i < 100; i++){ 
                System.out.println("main" + i);
                if(i == 98){ 
                    //调用stop方法切换标志位，让线程停止
                    testStop.stop();
                    System.out.println("线程该终止了");
                }
            }
        }
    }

## 九、线程休眠 ##

*  slee指定当前进程阻塞的毫秒数
 *  sleep存在异常InterruptedException
 *  sleep时间到达后线程进入就绪状态
 *  sleep可以模拟网络延时，倒计时等
 *  每一个对象都有一个锁，sleep不会释放锁

代码示例：

//模拟网络延时，放大问题的发生性
    public class TestSleep implements Runnable{ 
    
        private  int tickNums = 10;
    
        @Override
        public void run(){ 
            while(true){ 
                if(tickNums <= 1){ 
                    break;
                }
                try{ 
                    Thread.sleep(200);
                }catch (InterruptedException e){ 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->拿到了第" + tickNums-- + "票");
            }
        }
        public static void main(String[] args) { 
    
            TestSleep ticket = new TestSleep();
    
            new Thread(ticket,"小明").start();
            new Thread(ticket,"小红").start();
            new Thread(ticket,"黄牛").start();
    
    
        }
    }

[多线程练习：打印当前电脑时间][Link 2]

## 十、线程礼让 ##

*  礼让线程，让当前正在执行的线程暂停，但不阻塞
 *  将线程从运行状态转为就绪状态
 *  **让CPU重新调度，礼让不一定成功！看CPU信息**

代码展示：

public class TestYield { 
    
        public static void main(String[] args) { 
            MyYield myYield = new MyYield();
            new Thread(myYield,"a").start();
            new Thread(myYield,"b").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合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞。
 *  可以想象成插队

public class TestJoin implements Runnable{ 
        @Override
        public void run(){ 
            for(int i = 0; i < 20; i++){ 
                System.out.println("线程vip来了" + i);
    
            }
    
        }
    
        public static void main(String[] args) throws InterruptedException{ 
    
            //启动我们的线程
            TestJoin testJoin = new TestJoin();
            Thread thread = new Thread(testJoin);
            thread.start();
    
            //主线程
            for (int i = 0; i < 10; i++){ 
                if(i == 3){ 
                    thread.join();//插队
                }
                System.out.println("main" + i);
            }
        }
    }

## 十二、线程状态观测 ##

Thread.State 线程状态，线程可以处于一下状态之一：

*  NEW  
    尚未启动的线程处于此状态
 *  RUNNABLE  
    在Java虚拟机中执行的线程处于此状态
 *  BLOCKEO  
    被阻塞等待监视器锁定的线程处于此状态
 *  WAITING  
    正在等待另一个线程执行特定动作的线程处于此状态
 *  TIME\_WAITING  
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
 *  TERMINATED  
    已退出的线程处于此状态

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态

//观察测试进程状态
    public class TestState { 
    
        public static void main(String[] args) throws Exception{ 
            Thread thread = new Thread(() -> { 
               for(int i = 0; i < 5; i++){ 
                   try{ 
                       Thread.sleep(1000);
                   }catch (InterruptedException e){ 
                       e.printStackTrace();
                   }
               }
               System.out.println("");
            });
    
         //观察状态
         Thread.State state = thread.getState();
         System.out.println(state);
    
         //观察启动后
         thread.start();//启动线程
         state = thread.getState();
         System.out.println(state);//Run
    
         while(state != Thread.State.TERMINATED){ //只要线程不停止，就一直输出状态
             Thread.sleep(100);
             state = thread.getState();//更新线程状态
             System.out.println(state);//输出状态
          }
         
        }
    }

## 十三、线程的优先级 ##

*  Java提供一个线程调度器来监控程序启动后进入就绪状态的所以线程，线程调度器按照优先级决定应该调度那个线程来执行
 *  线程的优先级用数字表示，范围从1~10  
    \-Thread.MIN\_PRIORITY = 1;  
    \-Thread.MAX\_PRIORITY = 10;  
    \-Thread.NORM\_PRIORITY = 5;
 *  使用一下方式改变或获取优先级  
    getPriority().setPriority(ing xxx)

注意：线程优先级高不一定限制性，线程的调用是看cpu，优先级高代表线程权重大。

优先级的设定建议在start()调度前。

代码示例：

public class TestPriority { 
    
        public static void main(String[] args) { 
    
            //主线程默认优先级
            System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    
            MyPriority myPriority = new MyPriority();
    
            Thread t1 = new Thread(myPriority);
            Thread t2 = new Thread(myPriority);
            Thread t3 = new Thread(myPriority);
            Thread t4 = new Thread(myPriority);
    
            t1.start();
    
            t2.setPriority(1);
            t2.start();
    
            t3.setPriority(5);
            t3.start();
    
            t4.setPriority(Thread.MAX_PRIORITY);
            t4.start();
        }
    }
    
    class  MyPriority implements Runnable{ 
    
        @Override
        public void run(){ 
            System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
        }
    }

结果：

> main–>5  
> Thread-0–>5  
> Thread-1–>1  
> Thread-2–>5  
> Thread-3–>10

## 十四、守护（daemon）线程 ##

*  线程分为用户线程和守护线程
 *  虚拟机必须确保用户线程执行完毕
 *  虚拟机不用等待守护线程执行完毕
 *  如、后台记录操作日志，监控内存，垃圾回收等待。

代码示例：

//上帝保护你
    public class TestDaemon { 
    
        public static void main(String[] args) { 
            God god = new God();
            You you = new You();
    
            Thread thread = new Thread(god);
            thread.setDaemon(true);//默认是false表示是用户守护线程，正常的线程都是用户线程
    
            thread.start();//上帝守护线程启动
    
            new Thread(you).start();// 你 用户线程启动
        }
    }
    
    //上帝
    class  God implements Runnable{ 
        @Override
        public void run(){ 
            while(true){ 
                System.out.println("上帝保佑着你 ");
            }
        }
    }
    
    //你
    class You implements Runnable{ 
        @Override
        public void run(){ 
            for(int i = 0; i < 36500; i++){ 
                System.out.println("愿你一生开心的活着");
            }
            System.out.println("=====goodbye world!====");
        }
    }

## 十五、线程同步 ##

多个线程操作统一资源

**并发**：同一个对象被多个线程同时操作

*  处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，下一个线程在使用。
 *  由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后试放锁即可，存在一下问题：
    
        1、一个线程持有锁会导致其他所有需要此锁的线程挂起
        2、在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和 调度延时，引起性能问题；
        3、如果一个优先级高的线程等待一个优先级低的线程试放锁会导致优先级倒置，引起性能问题。

代码示例：

//不安全的买票
    //线程不安全，结果出现负数
    public class UnsafeBuyTicket { 
    
        public static void main(String[] args) { 
            BuyTicket station = new BuyTicket();
    
            new Thread(station, "苦逼的我").start();
            new Thread(station, "牛逼的你").start();
            new Thread(station, "可恶的黄牛党").start();
        }
    }
    
    class BuyTicket implements Runnable{ 
    
        //票
        int ticketNums = 10;
        boolean flag = true;//外部停止方式
    
        @Override
        public void run(){ 
            //买票
            while (flag){ 
                try{ 
                    buy();
                }catch (InterruptedException e){ 
                    e.printStackTrace();
                }
    
            }
        }
    
        private void buy() throws InterruptedException{ 
            if(ticketNums <= 0){ 
                return;
            }
    
            //模拟延时
            Thread.sleep(100);
    
            //买票
            System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
        }
    }

**同步方法：**

*  由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一台机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块

> 同步方法：public synchronized void method(int args)\{\}

*  synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放，后面被阻塞的线程才能获得这个锁，继续执行

> 缺陷：若将一个大的方法申明为synchronized将会影响效率

**同步块：**

*  同步块：synchronized(Obj)\{\}
 *  Obj称之为*同步监视器*
    
     *  Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
     *  同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class\[反射中讲解\]
 *  同步监视器的执行过程

> 1、第一个线程访问，锁定同步监视器，执行其中代码  
> 2、第二个线程访问，发现同步监视器被锁定，无法访问  
> 3、第一个线程访问完毕，解锁同步监视器  
> 4、第二个线程访问，发现同步监视器没有锁，然后锁定并访问

代码示例：

//不安全的买票
    //线程不安全，结果出现负数
    public class UnsafeBuyTicket { 
    
        public static void main(String[] args) { 
            BuyTicket station = new BuyTicket();
    
            new Thread(station, "苦逼的我").start();
            new Thread(station, "牛逼的你").start();
            new Thread(station, "可恶的黄牛党").start();
        }
    }
    
    class BuyTicket implements Runnable{ 
    
        //票
        int ticketNums = 10;
        boolean flag = true;//外部停止方式
    
        @Override
        public void run(){ 
            //买票
            while (flag){ 
                try{ 
                    buy();
                }catch (InterruptedException e){ 
                    e.printStackTrace();
                }
    
            }
        }
    
        //synchronized 加入锁后结果正常
        private synchronized void buy() throws InterruptedException{ 
            if(ticketNums <= 0){ 
                return;
            }
    
            //模拟延时
            Thread.sleep(100);
    
            //买票
            System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
        }
    }

## 十六、死锁 ##

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都等待对方释放资源，都停止执行的情形，某一个同步代码块同时拥有"两个以上对象的锁"时，就可能发生“死锁”的问题

代码示例：

public class deadLock { 
    
        public static void main(String[] args) { 
            MakeUp g1 = new MakeUp(0, "灰姑娘");
            MakeUp g2 = new MakeUp(1, "白雪公主");
    
            g1.start();
            g2.start();
        }
    }
    
    //口红
    class Lipstick{ 
    
    }
    //镜子
    class Mirror{ 
    
    }
    
    class MakeUp extends Thread{ 
        //需要的资源只有一份，用static来保证只有一份
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        int choice;//选择
        String girName;//使用化妆品的人
    
        MakeUp(int choice, String girName){ 
            this.choice = choice;
            this.girName = girName;
        }
    
        @Override
        public void run(){ 
            //化妆
            try { 
                makup();
            }catch (InterruptedException e){ 
                e.printStackTrace();
            }
    
        }
        //化妆，互相持有对方的锁，就是需要拿到对方的资源
        private void makup()throws InterruptedException{ 
            if(choice==0){ 
                synchronized(lipstick){ //获得口红的锁
                    System.out.println(this.girName + "获得口红的锁");
                    Thread.sleep(1000);
    
                    synchronized (mirror){ 
                        System.out.println(this.girName + "获得镜子的锁");
                    }
                }
            }
            else{ 
                synchronized(mirror){ 
                    System.out.println(this.girName + "获得镜子的锁");
                    Thread.sleep(2000);
    
                    synchronized (lipstick){ 
                        System.out.println(this.girName + "获得口红的锁");
                    }
                }
            }
        }
    }

解决死锁后的代码：

public class deadLock { 
    
        public static void main(String[] args) { 
            MakeUp g1 = new MakeUp(0, "灰姑娘");
            MakeUp g2 = new MakeUp(1, "白雪公主");
    
            g1.start();
            g2.start();
        }
    }
    
    //口红
    class Lipstick{ 
    
    }
    //镜子
    class Mirror{ 
    
    }
    
    class MakeUp extends Thread{ 
        //需要的资源只有一份，用static来保证只有一份
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        int choice;//选择
        String girName;//使用化妆品的人
    
        MakeUp(int choice, String girName){ 
            this.choice = choice;
            this.girName = girName;
        }
    
        @Override
        public void run(){ 
            //化妆
            try { 
                makup();
            }catch (InterruptedException e){ 
                e.printStackTrace();
            }
    
        }
        //化妆，互相持有对方的锁，就是需要拿到对方的资源
        private void makup()throws InterruptedException{ 
            if(choice==0){ 
                synchronized(lipstick){ //获得口红的锁
                    System.out.println(this.girName + "获得口红的锁");
                    Thread.sleep(1000);
                }
                synchronized (mirror){ 
                    System.out.println(this.girName + "获得镜子的锁");
                }
            }
            else{ 
                synchronized(mirror){ 
                    System.out.println(this.girName + "获得镜子的锁");
                    Thread.sleep(2000);
                    }
                synchronized (lipstick){ 
                    System.out.println(this.girName + "获得口红的锁");
                }
            }
        }
    }

**死锁的避免方法：**

*  产生死锁的四个必要条件：

> 1、互斥条件：一个资源每次只能被一个进程使用  
> 2、请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放  
> 3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺  
> 4、循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
> 
> 上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

## 十七、Lock(锁) ##

ReentrantLock类实现了Lock，它拥有synchronized相同的并发现和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock（可重复锁），可以显示加锁、释放锁。

代码示例：

class A{ 
    		private final ReentrantLock lock = new ReenTrantLock();
    		public void m(){ 
    		       lock.lock();
    		       try{ 
    		       			//保证线程安全的代码
    		       }
    		       finally{ 
    		       lock.unlock();
    		       //如果同步代码有异常，要将unlock()写入finally语句块
    		       }
    		   }
    }

import java.util.concurrent.locks.ReentrantLock;
    
    public class TestLock { 
        public static void main(String[] args) { 
            TestLock2 testLock2 = new TestLock2();
    
        }
    
    }
    
    class TestLock2 implements Runnable{ 
    
        int tickNums = 10;
    
        //定义Lock锁
        ReentrantLock lock = new ReentrantLock();
    
        public void run(){ 
            while (true){ 
    
                try{ 
                    lock.lock();//加锁
                    if(tickNums > 0){ 
                        try{ 
                            Thread.sleep(1000);
                        }catch (InterruptedException e){ 
                            e.printStackTrace();
                        }
                        System.out.println((tickNums--));
                    }
                    else{ 
                        break;
                    }
                }finally { 
                    //解锁
                    lock.unlock();
    
                }
    
            }
        }
    }

**synchronized 与 Lock 的对比**

*  Lock是显示锁（手动开启和关闭，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
 *  Lock只有代码块锁，synchronized有代码块锁和方法锁
 *  使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性
 *  优先使用顺序：Lock>同步代码块>同步方法

## 十八、 线程通信 ##

Java提供了几个方法解决线程之间的通信

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>wait()</td> 
   <td>表示线程一直等待，直到其他线程通知，与sleep不同</td> 
  </tr> 
  <tr> 
   <td>wait(long timeout)</td> 
   <td>指定等待的毫秒数</td> 
  </tr> 
  <tr> 
   <td>notify</td> 
   <td>唤醒一个处于等待状态的线程</td> 
  </tr> 
  <tr> 
   <td>notifyAll</td> 
   <td>唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度</td> 
  </tr> 
 </tbody> 
</table>

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException

[生产者和消费者问题模型及两种解决方法][Link 3]

## 十九、使用线程池 ##

*  背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
 *  思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具。
 *  好处：  
    1、 提高相应速度（减少了创建新线程的时间）  
    2、降低资源消耗（重复利用线程池中线程，不需要每次都创建）  
    3、便于线程管理：corePoolSeze（核心池的大小）、maximumPoolSize（最大线程数）、keepAliveTime（线程没有任务最多保持多长时间后会终止）
 *  JDK 5.0起提供了线程池相关API：**EexcutorService** 和 **Executors**

EexcutorService:

> 1、void execute(Runnable command): 执行任务/命令，没有返回值，一般用来执行Runnable  
> 2、< T >Future< T >submit(Callable< T >task:执行任务，有返回值，一般又来执行Callable  
> 3、void shutdown(): 关闭连接池

Executors：

> 工具类、线程池的工程类，用于创建并返回不同类型的线程池

代码示例：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    //测试线程池
    public class TestPool { 
    
        public static void main(String[] args) { 
    
            //1、创建服务，创建线程池
            //newFixedThreadPool 参数为线程池大小
            ExecutorService service = Executors.newFixedThreadPool(10);
    
            //执行
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
    
            //2、关闭链接
            service.shutdown();
    
        }
    }
    
    class MyThread implements Runnable{ 
        @Override
        public void run(){ 
            System.out.println(Thread.currentThread().getName());
        }
    
    }

## 二十、总结 ##

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class ThreadNew { 
        public static void main(String[] args) { 
            new MyThread1().start();
            new Thread(new MhThread2()).start();
    
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
            new Thread(futureTask).start();
    
            try{ 
                Integer integer = futureTask.get();
                System.out.println(integer);
            }catch (InterruptedException e){ 
                e.printStackTrace();
            }catch (ExecutionException e){ 
                e.printStackTrace();
            }
        }
    }
    
    //1、继承Thread类
    class MyThread1 extends Thread{ 
        @Override
        public void run(){ 
            System.out.println("MyThread1");
        }
    }
    
    //2、实现Runnable接口
    class MhThread2 implements Runnable{ 
        @Override
        public void run(){ 
            System.out.println("MhThread2");
        }
    }
    
    //3、实现Callable接口
    class MyThread3 implements Callable<Integer>{ 
        @Override
        public Integer call() throws Exception{ 
            System.out.println("MhThread3");
            return 100;
        }
    }

[Link 1]: https://blog.csdn.net/weixin_44096353/article/details/118532004?spm=1001.2014.3001.5501
[------Proxy]: https://blog.csdn.net/weixin_44096353/article/details/118539770
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/058cfaee44704449a50e0df79da05aee.png
[Link 2]: https://blog.csdn.net/weixin_44096353/article/details/118556138?spm=1001.2014.3001.5501
[Link 3]: https://blog.csdn.net/weixin_44096353/article/details/118579888