• Java多线程

    目录

    线程简介

    多任务

    • 现实中太多这样同时做很多事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事。

    多线程

    • 原来是一条路，慢慢因为车多了，道路堵塞，效率极低。为了提高使用效率，能够充分利用道路，于是增加了多个车道，就不用担心车会堵塞了。

    普通方法调用和多线程

    程序.进程.线程

    Process与Thread

    • 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
    • 而进程则是执行程序的一次执行过程，它是一个运动的概念。是系统资源分配的单位。
    • 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
    • 主意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

    线程实现

    三种创建方式

    继承Thread类

    • 自定义线程类继承Thread类
    • 重写run（）方法，编写线程执行体
    • 创建线程对象，调用start（）方法启动线程

    演示：多线程的交替执行

    1. package JavaSE;
    2. //创建线程方式一：继承Thread类，重写run（）方法，调用start开启线程
    3. public class TestThread extends Thread{
    4.     @Override
    5.     public void run() {
    6.         //run方法线程体
    7.         for (int i = 0; i < 20; i++) {
    8.             System.out.println("我在看代码---"+i);
    9.         }
    10.     }
    11.  
    12.     public static void main(String[] args) {
    13.         //main线程，主线程
    14.  
    15.         //创建一个线程对象，调用start方法开启线程
    16.         TestThread testThread = new TestThread();
    17.         testThread.start();
    18.  
    19.         for (int i = 0; i < 20; i++) {
    20.             System.out.println("我在学习多线程---"+i);
    21.             
    22.         }
    23.     }
    24. }
    25.

    结论

    线程不一定立即执行，CPU安排调度

    实现Runnable接口

    • 定义MyRunnable类实现Runnable接口
    • 实现run（）方法，编写线程执行体
    • 创建线程对象，调用start（）方法启动线程

    演示：实现Runnable接口

    1. package JavaSE;
    2. //创建线程方式一：实现Runnable接口，重写run（）方法，执行线程需要丢入runnable接口实现类，调用start方法。
    3. public class TestThread implements Runnable {
    4.         @Override
    5.         public void run() {
    6.             //run方法线程体
    7.             for (int i = 0; i < 200; i++) {
    8.                 System.out.println("我在看代码---"+i);
    9.             }
    10.         }
    11.  
    12.         public static void main(String[] args) {
    13.             //main线程，主线程
    14.             //创建runnable接口的实现类对象
    15.             TestThread testThread = new TestThread();
    16.             //创建线程对象，通过线程对象来开启我们的线程，代理
    17.             Thread thread = new Thread(testThread);
    18.             thread.start();
    19.  
    20.             //可合并为一句代码
    21.             //new Thread(testThread).start();
    22.  
    23.             for (int i = 0; i < 200; i++) {
    24.                 System.out.println("我在学习多线程---"+i);
    25.             }
    26.         }
    27.     }

    Thread和Runnable对比

    • 继承Thread类
      • 子类继承Thread类具备多线程能力
      • 启动线程：子类对象.start（）
      • 不建议使用：避免OOP单继承局限性
    • 实现Runnable接口
      • 实现接口Runnable具有多线程能力
      • 启动线程：传入目标对象+Thread对象.start（）
      • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

    演示：多个线程同时操作同一个对象

    1. package JavaSE;
    2. //多个线程同时操作同一个对象
    3. //买火车票的例子
    4. public class TestThread1 implements Runnable {
    5.  
    6.     //票数
    7.     private int ticketNums = 10;
    8.  
    9.     @Override
    10.     public void run() {
    11.         while(true){
    12.  
    13.             if(ticketNums<=0){
    14.                 break;
    15.             }
    16.             //模拟延时
    17.             try {
    18.                 Thread.sleep(200);
    19.             } catch (InterruptedException e) {
    20.                 throw new RuntimeException(e);
    21.             }
    22.             System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
    23.         }
    24.     }
    25.  
    26.     public static void main(String[] args) {
    27.         TestThread1 ticket = new TestThread1();
    28.  
    29.         new Thread(ticket,"小明").start();
    30.         new Thread(ticket,"老师").start();
    31.         new Thread(ticket,"黄牛党").start();
    32.     }
    33. }

    发现问题

    多个线程操作同一个资源的情况下，线程不安全，数据紊乱。

    案例：龟兔赛跑

    1.首先来个赛道距离，然后要离终点越来越近

    2.判断比赛是否结束

    3.打印出胜利者

    4.龟兔赛跑开始

    5.故事中是乌龟赢的，兔子需要睡觉，所以我们需要模拟兔子睡觉

    6.最终，乌龟赢得了比赛

    演示

    1. package JavaSE;
    2. //模拟龟兔赛跑
    3. public class Race implements Runnable{
    4.  
    5.     //胜利者
    6.     private String winner;
    7.  
    8.     @Override
    9.     public void run() {
    10.         for (int i = 0; i <= 100; i++) {
    11.  
    12.             //模拟兔子休息
    13.             if (Thread.currentThread().getName().equals("兔子")&& i%10==0){
    14.                 try {
    15.                     Thread.sleep(1);
    16.                 } catch (InterruptedException e) {
    17.                     throw new RuntimeException(e);
    18.                 }
    19.             }
    20.             //判断比赛是否结束
    21.             boolean flag = gameOver(i);
    22.             //如果比赛结束了，就停止程序
    23.             if(flag){
    24.                 break;
    25.             }
    26.  
    27.             System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
    28.         }
    29.     }
    30.     //判断是否完成比赛
    31.     private boolean gameOver(int steps){
    32.         //判断是否有胜者
    33.         if(winner!=null){//已经存在胜利者了
    34.             return true;
    35.         } {
    36.             if(steps>=100){
    37.                 winner = Thread.currentThread().getName();
    38.                 System.out.println("winner is "+winner);
    39.                 return true;
    40.             }
    41.         }
    42.         return false;
    43.     }
    44.  
    45.     public static void main(String[] args) {
    46.         Race race = new Race();
    47.  
    48.         new Thread(race,"兔子").start();
    49.         new Thread(race,"乌龟").start();
    50.     }
    51. }

    实现Callable接口

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

    静态代理

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

    演示：实现静态代理对比Thread

    1. package JavaSE;
    2.  
    3. //静态代理总结：
    4. //真实对象和代理对象都要实现同一个接口
    5. //代理对象要代理真实角色
    6. //婚庆公司==Thread（）
    7. //You（）==要调用线程的对象，调用的方法及run（）在这里就是labmda表达式实现的方法
    8.  
    9. //好处：
    10.         //代理对象可以做很多真实对象做不了的事情
    11.         //真实对象就专注做自己的事情
    12. public class StaticProxy {
    13.     public static void main(String[] args) {
    14.         You you = new You();
    15.         new Thread( () -> System.out.println("我爱你")).start();
    16.  
    17.         new WeddingCompany(new You()).HappyMarry();
    18.  
    19.        /**  可简化为上面一行
    20.         WeddingCompany weddingCompany = new WeddingCompany(new You());
    21.         weddingCompany.HappyMarry();
    22.         */
    23.  
    24.     }
    25. }
    26.  
    27. interface Marry{
    28.     void HappyMarry();
    29. }
    30.  
    31. //真实角色，你去结婚
    32. class You implements Marry{
    33.     @Override
    34.     public void HappyMarry() {
    35.         System.out.println("我要结婚了，超开心");
    36.     }
    37. }
    38.  
    39.  
    40. //代理角色，帮助你去结婚
    41. class WeddingCompany implements Marry{
    42.  
    43.     private Marry target;
    44.     public WeddingCompany(Marry target){
    45.         this.target = target;
    46.     }
    47.     @Override
    48.     public void HappyMarry() {
    49.         before();
    50.         this.target.HappyMarry();   //这就是真实对象
    51.         after();
    52.     }
    53.  
    54.     private void after() {
    55.         System.out.println("结婚之后，收尾款");
    56.     }
    57.  
    58.     private void before() {
    59.         System.out.println("结婚之前，布置现场");
    60.     }
    61. }

    lambda表达式

    • λ希腊字母中排序第十一位，英语名为lambda

    • 避免匿名内部类定义过多
    • 其实质属于函数式编程的概念
    • 用法：new Thread( () -> System.out.println("多线程")).start();

    • 为什么要使用lambda表达式
      • 避免匿名内部类定义过多
      • 可以让你的代码看起来很简洁
      • 去掉了一堆没有意义的代码，只留下核心的逻辑
    • 理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在
    • 函数式接口的定义：
      • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

      • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

    演示1：lambda表达式的推导

    1. package JavaSE;
    2. //推导lambda表达式
    3. public class TestLambda {
    4.  
    5.     //3.静态内部类
    6.     static class Like1 implements ILike{
    7.         @Override
    8.         public void lambda() {
    9.             System.out.println("i like lambda1");
    10.         }
    11.     }
    12.  
    13.     public static void main(String[] args) {
    14.         ILike like = new Like();
    15.         like.lambda();
    16.  
    17.         like = new Like1();
    18.         like.lambda();
    19.  
    20.         //4.局部内部类
    21.         class Like2 implements ILike{
    22.             @Override
    23.             public void lambda() {
    24.                 System.out.println("i like lambda2");
    25.             }
    26.         }
    27.  
    28.         like = new Like2();
    29.         like.lambda();
    30.  
    31.         //5.匿名内部类,没有类的名称，必须借助接口或者父类
    32.         like = new  ILike(){
    33.             @Override
    34.             public void lambda() {
    35.                 System.out.println("i like lambda3");
    36.             }
    37.         };
    38.         like.lambda();
    39.  
    40.         //6.用lambda简化
    41.         like = ()->{
    42.             System.out.println("i like lambda4");
    43.         };
    44.         like.lambda();
    45.  
    46.     }
    47. }
    48.  
    49. //1.定义一个函数式接口
    50. interface ILike{
    51.     void lambda();
    52. }
    53.  
    54. //2.实现类
    55. class Like implements ILike{
    56.     @Override
    57.     public void lambda() {
    58.         System.out.println("i like lambda");
    59.     }
    60. }

    演示2：lambda表达式的简化

    1. package JavaSE;
    2.  
    3. public class TestLambda1 {
    4.     public static void main(String[] args) {
    5.  
    6.         ILove love = null;
    7.  /*       //1.lambda表达简化
    8.         ILove love =(int a)-> {
    9.                 System.out.println("I love you-->"+a);
    10.         };
    12.         //简化1.参数类型
    13.         love = (a)-> {
    14.             System.out.println("I love you-->"+a);
    15.         };
    17.         //简化2.简化括号
    18.         love = a->{
    19.             System.out.println("I love you-->"+a);
    20.         };*/
    21.  
    22.         //简化3.去掉花括号
    23.         love = a-> System.out.println("I love you-->"+a);
    24.  
    25.         love.love(521);
    26.  
    27.     }
    28. }
    29.  
    30. //实现类
    31. interface ILove{
    32.     void love(int a);
    33. }

    总结

    1. lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹
    2. 前提是接口为函数式接口
    3. 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号

    线程状态

    概述

    五大状态

    线程方法

    停止线程

    • 不推荐使用JDK提供的stop（）、destroy方法。（已废弃）
    • 推荐线程自己停止下来
    • 建议使用一个标志位进行终止变量，当flag = false，则终止线程运行。

    线程停止

    演示

    1. //测试stop
    2.  
    3. //1.建议线程正常停止--->利用次数，不建议死循环
    4.  
    5. //2.建议使用标志位--->设置一个标志位
    6.  
    7. //3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
    8.  
    9. package JavaSE;
    10.  
    11. public class TestStop implements Runnable{
    12.     //1.设置一个标志位
    13.     private boolean flag = true;
    14.     @Override
    15.  
    16.     public void run(){
    17.  
    18.         int i =0;
    19.  
    20.         while(flag){
    21.  
    22.             System.out.println("run...Thread"+i++);
    23.         }
    24.     }
    25.  
    26.     //2.设置一个公开的方法停止线程，转换标志位
    27.     public void stop(){
    28.         this.flag = false;
    29.     }
    30.     public static void main(String []args){
    31.  
    32.         TestStop testStop = new TestStop();
    33.         new Thread(testStop).start();
    34.  
    35.         for(int i = 0;i < 1000;i++){
    36.             System.out.println("main"+i);
    37.             if(i==900){
    38.  
    39.                 //调用stop方法切换标志位，让线程停止
    40.                 testStop.stop();
    41.                 System.out.println("线程该停止了");
    42.             }
    43.         }
    44.     }
    45. }

    线程休眠_sleep

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

    演示：计时：模拟倒计时

    1. //模拟网络延时：放大问题的发生性
    2. package JavaSE;
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5.  
    6. public class TestSleep2{
    7.  
    8. /* //倒计时
    9. 	Public static void main(String[] args){
    10. 		try{
    11. 			tenDown();
    12. 		}catch(InterruptedException e){
    13. 			E.printStackTrace();
    14. 		}
    15. 	}
    16. */
    17.  
    18.     public  static void main(String[] args){
    19.         //打印当前系统时间
    20.         Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
    21.  
    22.         while(true){
    23.             try{
    24.                 Thread.sleep(1000);
    25.                 System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
    26.                 startTime = new Date(System.currentTimeMillis());//更新当前时间
    27.             }catch(InterruptedException e){
    28.                 e.printStackTrace();
    29.             }
    30.         }
    31.     }
    32. //模拟倒计时
    33.  
    34.     public void tenDown() throws InterruptedException{
    35.         int num = 10;
    36.         while(true){
    37.             Thread.sleep(1000);
    38.             System.out.println(num--);
    39.             if(num<=0){
    40.                 break;
    41.             }
    42.         }
    43.     }
    44. }
    45.

    线程礼让_yield

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

    演示：测试礼让线程

    1. //礼让不一定成功！看CPU心情
    2. public class TestYield{
    3.     
    4.     public static void main(String[] args){
    5.         MyYield myYield = new MyYield();
    6.         new Thread(myYield,"a").start();
    7.         new Thread(myYield,"b").start();
    8.     }
    9. }
    10.  
    11. class MyYield implements Runnable{
    12.     @Override
    13.     public void run(){
    14.         System.out.println(Thread.currentThread().getName()+"线程开始执行");
    15.         Thread.yield();//礼让
    16.         System.out.println(Thread.currentThread().getName()+"线程停止执行");
    17.     }
    18. }

    线程强制执行_Join

    • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
    • 可以想象成插队

    演示:测试join方法，想象为插队

    1. public class TestJoin implements Runnable{
    2.     
    3.      @Override
    4.      public void run(){
    5.          for(int i = 0;i<100;i++){
    6.               System.out.println("VIP来了"+i);
    7.          }
    8.      }
    9.     
    10.      public static void main(String[] args){
    11.          //启动我们的线程
    12.          TestJoin testJoin = new TestJoin();
    13.          Thread thread = new Thread(testJoin);
    14.          thread.start();
    15.          
    16.          //主线程
    17.          for(int i = 0;i<1000,i++){
    18.               if(i==200){
    19.                   thread.join();//插队
    20.               }
    21.              System.out.println("main"+i);
    22.          }
    23.          
    24.      }
    25. }

    线程状态观测

    • Thread.State

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

      • NEW

        尚未启动的线程处于此状态

      • RUNNABLE

        在Java虚拟机中执行的线程处于此状态

      • BLOCKED

        被阻塞等待监视器锁定的线程处于此状态

      • WAITING

        正在等待另一个线程执行特定动作的线程处于此状态

      • TIMED_WAITING

        正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

      • TERMINATED

        已退出的线程处于此状态

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

    演示：观察测试线程的状态

    1. public class TestState{
    2.     
    3. 	public static void main(String[] args){
    4.     	Thread thread = new Thread(()->{
    5.             for(int i = 0;i<5;i++){
    6.                 try{
    7.                     Thread.sleep(1000);
    8.                 }catch(InterruptedException e){
    9.                     e.printStackTrace();
    10.                 }
    11.             }
    12.             System.out.println("//");
    13.         });
    14.         
    15.         //观察状态
    16.         Thread.State state = thread.getState();
    17.         System.out.println(state);//NEW
    18.         
    19.         //观察启动后
    20.         thread.start();//启动线程
    21.         state = thread.getState();
    22.         System.out.println(state);//Run
    23.         
    24.         while(state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
    25.             Thread.sleep(100);
    26.             state = thread.getState();//更新线程状态
    27.             System.out.println(state);//输出状态
    28.         }
    29. 	}
    30.     
    31. }

    线程优先级

    • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
    • 线程的优先级用数字来表示，范围从1-10
      • Thread.MIN_PRIORITY=1;
      • Thread.MIN_PRIORITY=5;
      • Thread.MIN_PRIORITY=10;
    • 使用以下方式改变或获取优先级
      • getPriority().setPriority(int xxx)
    • 优先级低只是意味着获得的调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度

    演示：测试线程的优先级

    1. package JavaSE;
    2.  
    3. //测试线程的优先级
    4. public class TestPriority {
    5.     public static void main(String[] args) {
    6.         //主线程默认优先级
    7.         System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    8.  
    9.         MyPriority myPriority = new MyPriority();
    10.  
    11.         Thread t0 = new Thread(myPriority);
    12.         Thread t1 = new Thread(myPriority);
    13.         Thread t2 = new Thread(myPriority);
    14.         Thread t3 = new Thread(myPriority);
    15.         Thread t4 = new Thread(myPriority);
    16.         Thread t5 = new Thread(myPriority);
    17.  
    18.         //先设置优先级再启动
    19.         t0.setPriority(Thread.MAX_PRIORITY);
    20.         t0.start();
    21.  
    22.         t1.setPriority(Thread.MIN_PRIORITY);
    23.         t1.start();
    24.  
    25.         t2.setPriority(4);
    26.         t2.start();
    27.  
    28.         t3.setPriority(Thread.MAX_PRIORITY);//Thread.MAX_PRIORITY = 10
    29.         t3.start();
    30.  
    31.         t4.setPriority(Thread.MIN_PRIORITY);//Thread.MIN_PRIORITY = 1
    32.         t4.start();
    33.  
    34.         t5.setPriority(Thread.NORM_PRIORITY);//Thread.NORM_PRIORITY = 5
    35.         t5.start();
    36.  
    37.     }
    38. }
    39.  
    40. class MyPriority implements Runnable{
    41.     @Override
    42.     public void run() {
    43.         System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    44.     }
    45. }

    守护线程

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

    演示：人生不过三万天

    1. package JavaSE;
    2.  
    3. //测试守护线程
    4. //上帝守护你
    5. public class TestDaemon {
    6.     public static void main(String[] args) {
    7.         God god = new God();
    8.         You1 you1 = new You1();
    9.  
    10.         Thread thread = new Thread(god);
    11.         thread.setDaemon(true);//默认是false表示是用户线程，正常的用户线程都是用户线程
    12.         thread.start();//上帝守护线程启动
    13.  
    14.         new Thread(you1).start();//你 用户线程启动
    15.     }
    16. }
    17.  
    18. //上帝
    19. class God implements Runnable{
    20.     @Override
    21.     public void run() {
    22.         while (true){
    23.             System.out.println("上帝保佑着你");
    24.         }
    25.     }
    26. }
    27.  
    28. //你
    29. class You1 implements Runnable{
    30.     @Override
    31.     public void run() {
    32.         for (int i = 0; i < 36500; i++) {
    33.             System.out.println("你一生都开心的活着");
    34.         }
    35.         System.out.println("-=======goodbye!world!========");
    36.  
    37.     }
    38. }

    线程同步

    概述

    并发

    • 同一个对象被多个线程同时操作

    线程同步

    • 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来。
    • 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

    队列和锁

    • 由于同一线程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放即可，存在以下问题：
      • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
      • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
      • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。

    三大不安全案例

    演示1：不安全的买票

    1. import com.sun.org.apache.xpath.internal.SourceTree;
    2.  
    3. //不安全的买票
    4. public class UnsafeBuyTicket {
    5.  
    6.     public static void main(String[] args){
    7.         BuyTicket station = new BuyTicket();
    8.  
    9.         new Thread(station,"甲").start();
    10.         new Thread(station,"乙").start();
    11.         new Thread(station,"丙").start();
    12.  
    13.     }
    14. }
    15.  
    16. class BuyTicket implements Runnable{
    17.  
    18.     //票
    19.     private int ticketNums = 10;
    20.     boolean flag = true;//外部停止方式
    21.  
    22.     @Override
    23.     public void run(){
    24.         //买票
    25.         while(flag){
    26.             try{
    27.             buy();
    28.             }catch(InterruptedException e){
    29.                 e.printStackTrace();
    30.             }
    31.         }
    32.     }
    33.  
    34.     private void buy() throws InterruptedException{
    35.         //判断是否有票
    36.         if(ticketNums<=0){
    37.             flag = false;
    38.             return;             
    39.         }
    40.  
    41.         //模拟延时
    42.  
    43.         Thread.sleep(100);
    44.  
    45.         //买票
    46.         System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    47.     }
    48.  
    49. }

    结论

    线程不安全，有负数

    演示2：不安全的取钱

    1. //不安全的取钱
    2. //两个人去银行取钱，账户
    3. public class UnsafeBank {
    4.     public static void main(String[] args){
    5.         //账户
    6.         Account account = new Account(100,"结婚基金");
    7.  
    8.         Drawing you = new Drawing(account,50,"你");
    9.         Drawing girlFriend = new Drawing(account,100,"girlFriend");
    10.  
    11.         you.start();
    12.         girlFriend.start();
    13.  
    14.     }
    15.  
    16. }   
    17.  
    18. //账户
    19. class Account{
    20.     int money;//余额
    21.     String name;//卡名
    22.  
    23.     public Account(int money,String name){
    24.         this.money = money;
    25.         this.name = name;
    26.     }
    27. }
    28.  
    29. //银行：模拟取款
    30. class Drawing extends Thread {
    31.  
    32.     //账户
    33.     Account account;
    34.  
    35.     //取了多少钱
    36.     int drawdingMoney;
    37.  
    38.     //现在手里有多少钱
    39.     int nowMoney;
    40.     
    41.     public Drawing (Account account,int drawdingMoney,String name){
    42.         super(name);
    43.         this.account = account;
    44.         this.drawdingMoney = drawdingMoney;
    45.     }
    46.  
    47.     //取钱
    48.     @Override
    49.     public void run() {
    50.         //判断有没有钱
    51.         if(account.money-drawdingMoney<0){
    52.             System.out.println(Thread.currentThread().getName()+"钱不够，取不了！");
    53.             return;
    54.         }
    55.  
    56.         try{
    57.         Thread.sleep(1000);
    58.         }catch(InterruptedException e){
    59.             e.printStackTrace();
    60.         }
    61.  
    62.         //卡内余额 = 余额-你取的钱
    63.         account.money = account.money - drawdingMoney;
    64.         //你手里的钱
    65.         nowMoney = nowMoney + drawdingMoney;
    66.  
    67.         System.out.println(account.name+"余额为:"+account.money);
    68.         //Thread.currentThread().getName()=this.getName()
    69.         System.out.println(this.getName()+"手里的钱:"+nowMoney);
    70.     }
    71. }

    演示3：线程不安全的集合

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4.  
    5. //线程不安全的集合
    6. public class UnsafeList {
    7.     public static void main(String[] args){
    8.         List list = new ArrayList();
    9.         for(int i= 0;i<10000;i++){
    10.             new Thread(()->{
    11.                 list.add(Thread.currentThread().getName());
    12.             }).start();
    13.         }
    14.         System.out.println(list.size());
    15.     }
    16. }
    17.

    同步方法及同步块

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

    同步方法弊端

    • 方法里面需要修改的内容才需要锁，锁的太多，浪费资源

    同步块

    • 同步块：synchronized（Obj）{}
    • Obj称之为同步监视器
      • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
      • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射中讲解】
    • 同步监视器的执行过程
      1. 第一个线程访问，锁定同步监视器，执行其中代码
      2. 第二个线程访问，发现同步监视器被锁定，无法访问
      3. 第一个线程访问完毕，解锁同步监视器
      4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

    演示1：安全的买票

    1. import com.sun.org.apache.xpath.internal.SourceTree;
    2.  
    3. //安全的买票
    4. public class UnsafeBuyTicket {
    5.  
    6.     public static void main(String[] args){
    7.         BuyTicket station = new BuyTicket();
    8.  
    9.         new Thread(station,"甲").start();
    10.         new Thread(station,"乙").start();
    11.         new Thread(station,"丙").start();
    12.  
    13.     }
    14. }
    15.  
    16. class BuyTicket implements Runnable{
    17.  
    18.     //票
    19.     private int ticketNums = 10;
    20.     boolean flag = true;//外部停止方式
    21.  
    22.     @Override
    23.     public void run(){
    24.         //买票
    25.         while(flag){
    26.             try{
    27.  
    28.                 //模拟延时
    29.                 Thread.sleep(100);
    30.  
    31.             buy();
    32.             }catch(InterruptedException e){
    33.                 e.printStackTrace();
    34.             }
    35.         }
    36.     }
    37.  
    38. //synchronized  同步方法，锁的是this
    39.     private synchronized void buy() throws InterruptedException{
    40.         //判断是否有票
    41.         if(ticketNums<=0){
    42.             flag = false;
    43.             return;             
    44.         }
    45.  
    46.         //买票
    47.         System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    48.     }
    49.     
    50.  
    51. }

    演示2：安全的取钱

    1. //安全的取钱
    2. //两个人去银行取钱，账户
    3. public class UnsafeBank {
    4.     public static void main(String[] args){
    5.         //账户
    6.         Account account = new Account(100,"结婚基金");
    7.  
    8.         Drawing you = new Drawing(account,50,"你");
    9.         Drawing girlFriend = new Drawing(account,100,"girlFriend");
    10.  
    11.         you.start();
    12.         girlFriend.start();
    13.  
    14.     }
    15.  
    16. }   
    17.  
    18. //账户
    19. class Account{
    20.     int money;//余额
    21.     String name;//卡名
    22.  
    23.     public Account(int money,String name){
    24.         this.money = money;
    25.         this.name = name;
    26.     }
    27. }
    28.  
    29. //银行：模拟取款
    30. class Drawing extends Thread {
    31.  
    32.     //账户
    33.     Account account;
    34.  
    35.     //取了多少钱
    36.     int drawdingMoney;
    37.  
    38.     //现在手里有多少钱
    39.     int nowMoney;
    40.     
    41.     public Drawing (Account account,int drawdingMoney,String name){
    42.         super(name);
    43.         this.account = account;
    44.         this.drawdingMoney = drawdingMoney;
    45.     }
    46.  
    47.     //取钱
    48.     //synchronized  默认锁的是this
    49.     @Override
    50.     public  void run() {
    51.  
    52.         synchronized(account){
    53.             //判断有没有钱
    54.         if(account.money-drawdingMoney<0){
    55.             System.out.println(Thread.currentThread().getName()+"钱不够，取不了！");
    56.             return;
    57.         }
    58.  
    59.         try{
    60.         Thread.sleep(1000);
    61.         }catch(InterruptedException e){
    62.             e.printStackTrace();
    63.         }
    64.  
    65.         //卡内余额 = 余额-你取的钱
    66.         account.money = account.money - drawdingMoney;
    67.         //你手里的钱
    68.         nowMoney = nowMoney +drawdingMoney;
    69.  
    70.         System.out.println(account.name+"余额为:"+account.money);
    71.         //Thread.currentThread().getName()=this.getName()
    72.         System.out.println(this.getName()+"手里的钱:"+nowMoney);
    73.         } 
    74.     }
    75. }

    演示3：线程安全的集合

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4.  
    5. //线程不安全的集合
    6. public class UnsafeList {
    7.     public static void main(String[] args){
    8.         List list = new ArrayList();
    9.         for(int i= 0;i<10000;i++){
    10.             new Thread(()->{
    11.                 synchronized(list){
    12.                     list.add(Thread.currentThread().getName());
    13.                 }   
    14.             }).start();
    15.         }
    16.         System.out.println(list.size());
    17.     }
    18. }

    死锁

    • 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁‘时，就可能会发生”死锁“的问题
    • 产生死锁的四个必要条件
      1. 互斥条件：一个资源每次只能被一个进程使用
      2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
      3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
      4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
    • 上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

    演示：死锁

    1. import java.awt.Choice;
    2.  
    3. //死锁：多个线程互相抱着对方需要的资源，然后形成僵持
    4. public class DeadLock {
    5.  public static void main(String[] args){
    6.         Makeup girl1 = new Makeup(0, "灰姑娘");
    7.         Makeup girl2 = new Makeup(1, "白雪公主");
    8.  
    9.         girl1.start();
    10.         girl2.start();
    11.     }
    12. }
    13.  
    14. //口红
    15. class Lipstick{
    16.    
    17. }
    18.  
    19. //镜子
    20. class Mirror{
    21.  
    22. }
    23.  
    24. class Makeup extends Thread{
    25.  
    26.     //需要的资源只有一份，用static来保证只有一份
    27.     static Lipstick lipstick = new Lipstick();
    28.     static Mirror mirror = new Mirror();
    29.  
    30.     int choice;//选择
    31.     String girlName;//使用化妆品的人
    32.  
    33.     Makeup(int choice,String girlName){
    34.         this.choice = choice;
    35.         this.girlName = girlName;
    36.     }
    37.  
    38.  
    39.     @Override
    40.     public void run(){
    41.         //化妆
    42.         try{
    43.         makeup();
    44.         }catch (InterruptedException e){
    45.             e.printStackTrace();
    46.         }
    47.     }
    48.  
    49.     //化妆，互相持有对方的锁，就是需要拿到对方的资源
    50.     private void makeup() throws InterruptedException{
    51.         if(choice == 0){
    52.             synchronized(lipstick){//获得口红的锁
    53.                 System.out.println(this.girlName+"获得口红的锁");
    54.                 Thread.sleep(1000);
    55.             }
    56.             synchronized(mirror){//一秒钟后想获得镜子
    57.                     System.out.println(this.girlName+"获得镜子的锁");
    58.                 }
    59.         }else{
    60.             synchronized(mirror){//获得镜子的锁
    61.                 System.out.println(this.girlName+"获得镜子的锁");
    62.                 Thread.sleep(2000);
    63.             }
    64.             synchronized(lipstick){//一秒钟后想获得口红
    65.                     System.out.println(this.girlName+"获得口红的锁"); 
    66.                 }
    67.         }
    68.     }
    69. }

    Lock（锁）

    • 从JDK5.0开始，Java提供了更强大的线程同步机制—通过显式定义同步锁对象实现同步。同步锁使用Lock对象充当

    • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

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

    • 用法：

    1. class A{
    2.  
    3.     //定义lock锁
    4.     private final ReentrantLock lock = new ReentrantLock();
    5.     
    6.     public void m(){
    7.                 lock.lock();//加锁
    8.                 try{
    9.                     	//保证线程安全的代码
    10.                 }
    11.         finally{
    12.             lock.unlock();
    13.             //如果同步代码有异常，要将unlock（）写入finally语句块
    14.         }
    15.     }
    16. }

    演示：lock

    1. import java.util.concurrent.locks.ReentrantLock;
    2.  
    3. public class TestLock {
    4.     public static void main(String[] args){
    5.         TestLock2 testLock2 = new TestLock2();
    6.  
    7.         new Thread(testLock2).start();
    8.         new Thread(testLock2).start();
    9.         new Thread(testLock2).start();
    10.  
    11.     }
    12.  
    13. }
    14.  
    15. class TestLock2 implements Runnable{
    16.  
    17.     int ticketNum = 10; 
    18.  
    19.     //定义lock锁
    20.     private final ReentrantLock lock = new ReentrantLock();
    21.  
    22.     @Override
    23.     public void run(){
    24.         while(true){
    25.             try{
    26.                 lock.lock();//加锁
    27.                  if(ticketNum>0){
    28.                 try{
    29.                     Thread.sleep(1000);
    30.                 }catch(InterruptedException e){
    31.                     e.printStackTrace();
    32.                 }
    33.                 System.out.println(ticketNum--);
    34.             }else{
    35.                 break;
    36.             }
    37.             }finally{
    38.                 //解锁
    39.                 lock.unlock();
    40.             }   
    41.         }
    42.     }
    43. }

    synchronized与Lock的对比

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

    线程协作

    生产者消费者模式

    • 应用场景：生产者和消费者问题
      • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
      • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
      • 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

    线程通信-分析

    这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

    • 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
    • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
    • 在生产消费者问题中，仅有synchronized是不够的
      • synchronized可阻止并发更新同一个共享资源，实现了同步
      • synchronized不能用来实现不同线程之间的消息传递（通信）
    • Java提供了几个方法解决线程之间的通信问题

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

    解决方式1

    并发协作模型“生产者/消费者模式”--->管程法

    • 消费者：负责生产数据的模块（可能是方法，对象，线程，进程）
    • 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
    • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

    生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

    解决方式2

    • 并发协作模型“生产者/消费者模式”--->信号灯法

    演示：信号灯法

    1. package JavaSE;
    2.  
    3. //演示：录制节目，演员录制，观众等待
    4. public class TestPc {
    5.     public static void main(String[] args) {
    6.         TV tv = new TV();
    7.         new Actor(tv).start();
    8.         new Watcher(tv).start();
    9.     }
    10. }
    11.  
    12. //生产者-->演员
    13. class Actor extends Thread{
    14.     TV tv;
    15.  
    16.     public Actor(TV tv) {
    17.         this.tv = tv;
    18.     }
    19.  
    20.     @Override
    21.     public void run() {
    22.         for (int i = 0; i < 20; i++) {
    23.             if(i%2==0){
    24.                 this.tv.act("快乐大本营");
    25.             }else {
    26.                 this.tv.act("抖音：记录美好生活");
    27.             }
    28.         }
    29.     }
    30. }
    31.  
    32. //消费者-->观众
    33. class Watcher extends  Thread{
    34.     TV tv;
    35.  
    36.     public Watcher(TV tv) {
    37.         this.tv = tv;
    38.     }
    39.  
    40.     @Override
    41.     public void run() {
    42.         for (int i = 0; i < 20; i++) {
    43.             tv.watch();
    44.         }
    45.     }
    46. }
    47.  
    48. //产品-->节目
    49. class TV{
    50.     //演员表演，观众等待 T
    51.     //观众观看，演员等待 F
    52.     String voice;//表演的节目
    53.     boolean flag = true;
    54.  
    55.     //演员表演
    56.     public synchronized void act(String voice){
    57.         if(!flag){
    58.             try {
    59.                 this.wait();
    60.             } catch (InterruptedException e) {
    61.                 e.printStackTrace();
    62.             }
    63.         }
    64.  
    65.         System.out.println("演员表演了："+voice);
    66.         //通知观众观看
    67.         this.notify();//通知唤醒
    68.         this.voice = voice;
    69.         this.flag = !this.flag;
    70.     }
    71.  
    72.     //观众观看
    73.     public synchronized void watch(){
    74.         if (flag){
    75.             try {
    76.                 this.wait();
    77.             }catch(InterruptedException e){
    78.                 e.printStackTrace();
    79.             }
    80.         }
    81.         System.out.println("观众观看了："+voice);
    82.         //通知演员表演
    83.         this.notifyAll();
    84.         this.flag = !this.flag;
    85.     }
    86.  
    87. }

    线程池

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

    使用线程池

    • JDK5.0起提供了线程池相关API：ExecutorService和Executors
    • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
      • void executor(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
      • Futuresubmit(Callabletask):执行任务，有返回值，一般又来执行Callable
      • void shutdown（）：关闭连接池
    • Executor：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

    演示：线程池

    1. package JavaSE;
    2.  
    3. import java.util.concurrent.ExecutorService;
    4. import java.util.concurrent.Executors;
    5.  
    6. //测试线程池
    7. public class TestPool {
    8.  
    9.     public static void main(String[] args) {
    10.         //1.创建服务，创建线程池
    11.         //newFixedThreadPool    参数为：线程池大小
    12.         ExecutorService service = Executors.newFixedThreadPool(10);
    13.  
    14.         //执行
    15.         service.execute(new MyThread());
    16.         service.execute(new MyThread());
    17.         service.execute(new MyThread());
    18.         service.execute(new MyThread());
    19.  
    20.         //2.关闭连接
    21.         service.shutdown();
    22.  
    23.     }
    24. }
    25.  
    26. class MyThread implements Runnable{
    27.     @Override
    28.     public void run() {
    29.             System.out.println(Thread.currentThread().getName());
    30.     }
    31. }


     

  • 相关阅读:
    吃透MySQL（十四）：主从延时问题
    pytorch从零实现resnet
    Notepad++ 通过HexEditor插件查看.hprof文件、heap dump文件的堆转储数据
    【云计算赛项】职业技能竞赛--容器开发部分例题K8s编排部署WebMall
    java使用RestHighLevelClient操作elasticsearch客户端异常Content-Type: text/html
    【分享】MySQL安装、配置环境、创建数据库的方法
    day10.8ubentu流水灯
    fortify漏洞修复笔记
    C语言详解——操作符讲解
    【贝叶斯回归】【第 1 部分】--pyro库应用
  • 原文地址：https://blog.csdn.net/guanshengg/article/details/126424435