1.实现多线程

1.1 简单了解多线程【理解】

是指从软件或者硬件上实现多个线程并发执行的技术。
具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

1.2 并发和并行【理解】

  • 并行：在同一时刻，有多个指令在多个CPU上同时执行。（多核CPU下，每个核都可以调度运行线程，这时候线程是可以并行的）
  • 并发：在同一时刻，有多个指令在单个CPU上交替执行。（多个线程轮流使用CPU）

1.3 进程和线程【理解】

  • 进程：是正在运行的程序，当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
    独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
    动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
    并发性：任何进程都可以同其他进程一起并发执行
  • 线程：是进程中的单个顺序控制流，是一条执行路径
    单线程：一个进程如果只有一条执行路径，则称为单线程程序
    多线程：一个进程如果有多条执行路径，则称为多线程程序
  • 进程与线程的关系
    • 进程负责获取资源，线程负责执行任务
    • 一个程序至少一个进程，一个进程至少有一个线程
    • 进程间通信比较复杂，成本较高
    • 线程更轻量，线程切换成本相对进程较低
  • 引出若干问题
    • 什么是执行资源？
    • JAVA启动有没有进程产生？
    • JVM启动之后至少有几个线程？
      • 两个
      • main
      • GC
    • 多线程的作用？
      • 提高CPU利用率
    • JAVA支持多线程吗？

1.4 实现多线程方式一：继承Thread类【应用】

  • 方法介绍 | 方法名 | 说明 | | —- | —- | | void run() | 在线程开启后，此方法将被调用执行 | | void start() | 使此线程开始执行，Java虚拟机会调用run方法() |

  • 实现步骤

    • 定义一个类MyThread继承Thread类
    • 在MyThread类中重写run()方法
    • 创建MyThread类的对象
    • 启动线程
  • 代码演示 ```java public class MyThread extends Thread { @Override public void run() {
    1.   for(int i=0; i<100; i++) {
    2.       System.out.println(i);
    3.   }
    } } public class MyThreadDemo { public static void main(String[] args) {
    1.   MyThread my1 = new MyThread();
    2.   MyThread my2 = new MyThread();

// my1.run(); // my2.run();

  1.     //此线程开始执行; Java虚拟机调用此线程的run方法
  2.     my1.start();
  3.     my2.start();
  4. }

}

  2. <a name="5b27fed4"></a>
  3. ### 1.5 多线程实现方式-两个小问题
  5. - 为什么要重写run()方法？<br />因为run()是用来封装被线程执行的代码
  6. - run()方法和start()方法的区别？<br />run()：封装线程执行的代码，直接调用，相当于普通方法的调用<br />start()：启动线程；然后由JVM调用此线程的run()方法
  8. <a name="5b8fdda7"></a>
  9. ### 1.6 实现多线程方式二：实现Runnable接口【应用】
  11. - Thread构造方法
  12. | 方法名 | 说明 |
  13. | --- | --- |
  14. | Thread(Runnable target) | 分配一个新的Thread对象 |
  15. | Thread(Runnable target, String name) | 分配一个新的Thread对象 |
  17. - 实现步骤
  18.    - 定义一个类MyRunnable实现Runnable接口
  19.    - 在MyRunnable类中重写run()方法
  20.    - 创建MyRunnable类的对象
  21.    - 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  22.    - 启动线程
  23. - 代码演示
  24. ```java
  25. /**
  26.  * 实现多线程方式二：实现Runnable接口
  27.  */
  28. public class MainClass {
  29.     public static void main(String[] args) {
  30.         MyRunnable myRunnable1 = new MyRunnable();
  31.         Thread t1 = new Thread(myRunnable1);
  33.         MyRunnable myRunnable2 = new MyRunnable();
  34.         Thread t2 = new Thread(myRunnable2);
  36.         t1.start();
  37.         t2.start();
  38.     }
  39. }
  41. class MyRunnable implements Runnable {
  43.     @Override
  44.     public void run() {
  45.         for (int i = 0; i < 100; i++) {
  46.             System.out.println("Runnable实现多线程" + i);
  47.         }
  48.     }
  49. }

1.7 实现多线程方式三: 实现Callable接口【应用】

  • 方法介绍 | 方法名 | 说明 | | —- | —- | | V call() | 计算结果，如果无法计算结果，则抛出一个异常 | | FutureTask(Callable callable) | 创建一个 FutureTask，一旦运行就执行给定的 Callable | | V get() | 如有必要，等待计算完成，然后获取其结果 |

  • 实现步骤

    • 定义一个类MyCallable实现Callable接口
    • 在MyCallable类中重写call()方法
    • 创建MyCallable类的对象
    • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
    • 创建Thread类的对象，把FutureTask对象作为构造方法的参数
    • 启动线程
    • 再调用get方法，就可以获取线程结束之后的结果。

  • 代码演示

    1. public class MyCallable implements Callable<String> {
    2.   @Override
    3.   public String call() throws Exception {
    4.       for (int i = 0; i < 100; i++) {
    5.           System.out.println("跟女孩表白" + i);
    6.       }
    7.       //返回值就表示线程运行完毕之后的结果
    8.       return "答应";
    9.   }
    10. }
    11. public class Demo {
    12.   public static void main(String[] args) throws ExecutionException, InterruptedException {
    13.       //线程开启之后需要执行里面的call方法
    14.       MyCallable mc = new MyCallable();
    15.       //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
    16.       FutureTask<String> ft = new FutureTask<>(mc);
    17.       //创建线程对象
    18.       Thread t1 = new Thread(ft);
    19.       //开启线程
    20.       t1.start();
    22.       String s = ft.get();
    23.       System.out.println(s);
    24.   }
    25. }

1.8 三种实现方式的对比

  • 实现Runnable、Callable接口
    • 好处: 扩展性强，实现该接口的同时还可以继承其他的类
    • 缺点: 编程相对复杂，不能直接使用Thread类中的方法
  • 继承Thread类
    • 好处: 编程比较简单，可以直接使用Thread类中的方法
    • 缺点: 可以扩展性较差，不能再继承其他的类

1.9 设置和获取线程名称【应用】

  • 方法介绍 | 方法名 | 说明 | | —- | —- | | void setName(String name) | 将此线程的名称更改为等于参数name | | String getName() | 返回此线程的名称 | | Thread currentThread() | 返回对当前正在执行的线程对象的引用 |

  • 代码演示

    1. public class MyThread extends Thread {
    2.   public MyThread() {}
    3.   public MyThread(String name) {
    4.       super(name);
    5.   }
    7.   @Override
    8.   public void run() {
    9.       for (int i = 0; i < 100; i++) {
    10.           System.out.println(getName()+":"+i);
    11.       }
    12.   }
    13. }
    14. public class MyThreadDemo {
    15.   public static void main(String[] args) {
    16.       MyThread my1 = new MyThread();
    17.       MyThread my2 = new MyThread();
    19.       //void setName(String name)：将此线程的名称更改为等于参数 name
    20.       my1.setName("高铁");
    21.       my2.setName("飞机");
    23.       //Thread(String name)
    24.       MyThread my1 = new MyThread("高铁");
    25.       MyThread my2 = new MyThread("飞机");
    27.       my1.start();
    28.       my2.start();
    30.       //static Thread currentThread() 返回对当前正在执行的线程对象的引用
    31.       //System.out.println(Thread.currentThread().getName());
    32.   }
    33. }

  • 实现Runnable接口获取线程名称 ```java /**

    • 获取当前线程对象 */ public class MainClass { public static void main(String[] args) {
      1. Thread thread = new Thread(new MyRunnable());
      2. thread.start();
      } }

class MyRunnable implements Runnable {

  1. @Override
  2. public void run() {
  3.     for (int i = 0; i < 10; i++) {
  4.         //获取当前线程，得到线程名称
  5.         System.out.println(Thread.currentThread().getName() + "-" + i);
  6.     }
  7. }

}

  2. <a name="d6fbbfb5"></a>
  3. ### 1.10 线程休眠【应用】
  5. - 相关方法
  6. | 方法名 | 说明 |
  7. | --- | --- |
  8. | static void sleep(long millis) | 使当前正在执行的线程停留（暂停执行）指定的毫秒数 |
  10. - 代码演示
  11. ```java
  12. public class MyRunnable implements Runnable {
  13.     @Override
  14.     public void run() {
  15.         for (int i = 0; i < 100; i++) {
  16.             try {
  17.                 Thread.sleep(100);
  18.             } catch (InterruptedException e) {
  19.                 e.printStackTrace();
  20.             }
  22.             System.out.println(Thread.currentThread().getName() + "---" + i);
  23.         }
  24.     }
  25. }
  26. public class Demo {
  27.     public static void main(String[] args) throws InterruptedException {
  28.         /*System.out.println("睡觉前");
  29.         Thread.sleep(3000);
  30.         System.out.println("睡醒了");*/
  32.         MyRunnable mr = new MyRunnable();
  34.         Thread t1 = new Thread(mr);
  35.         Thread t2 = new Thread(mr);
  37.         t1.start();
  38.         t2.start();
  39.     }
  40. }

1.11 线程优先级【应用】

  • 线程调度
    • 两种调度方式
      • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
      • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
    • Java使用的是抢占式调度模型
    • 随机性
      假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

  • 优先级相关方法 | 方法名 | 说明 | | —- | —- | | final int getPriority() | 返回此线程的优先级 | | final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |

  • 代码演示

    1. public class MyCallable implements Callable<String> {
    2.   @Override
    3.   public String call() throws Exception {
    4.       for (int i = 0; i < 100; i++) {
    5.           System.out.println(Thread.currentThread().getName() + "---" + i);
    6.       }
    7.       return "线程执行完毕了";
    8.   }
    9. }
    10. public class Demo {
    11.   public static void main(String[] args) {
    12.       //优先级: 1 - 10 默认值:5
    13.       MyCallable mc = new MyCallable();
    15.       FutureTask<String> ft = new FutureTask<>(mc);
    17.       Thread t1 = new Thread(ft);
    18.       t1.setName("飞机");
    19.       t1.setPriority(10);
    20.       //System.out.println(t1.getPriority());//5
    21.       t1.start();
    23.       MyCallable mc2 = new MyCallable();
    25.       FutureTask<String> ft2 = new FutureTask<>(mc2);
    27.       Thread t2 = new Thread(ft2);
    28.       t2.setName("坦克");
    29.       t2.setPriority(1);
    30.       //System.out.println(t2.getPriority());//5
    31.       t2.start();
    32.   }
    33. }

1.12 守护线程【应用】

  • 相关方法 | 方法名 | 说明 | | —- | —- | | void setDaemon(boolean on) | 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 |

  • 代码演示

    1. public class MyThread1 extends Thread {
    2.   @Override
    3.   public void run() {
    4.       for (int i = 0; i < 10; i++) {
    5.           System.out.println(getName() + "---" + i);
    6.       }
    7.   }
    8. }
    9. public class MyThread2 extends Thread {
    10.   @Override
    11.   public void run() {
    12.       for (int i = 0; i < 100; i++) {
    13.           System.out.println(getName() + "---" + i);
    14.       }
    15.   }
    16. }
    17. public class Demo {
    18.   public static void main(String[] args) {
    19.       MyThread1 t1 = new MyThread1();
    20.       MyThread2 t2 = new MyThread2();
    22.       t1.setName("女神");
    23.       t2.setName("备胎");
    25.       //把第二个线程设置为守护线程
    26.       //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
    27.       t2.setDaemon(true);
    29.       t1.start();
    30.       t2.start();
    31.   }
    32. }

2.线程同步

2.1 卖票【应用】

  • 案例需求
    某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
  • 实现步骤
    • 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
    • 在SellTicket类中重写run()方法实现卖票，代码步骤如下
    • 判断票数大于0，就卖票，并告知是哪个窗口卖的
    • 卖了票之后，总票数要减1
    • 票卖没了，线程停止
    • 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
    • 创建SellTicket类的对象
    • 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
    • 启动线程

  • 代码实现

    1. public class SellTicket implements Runnable {
    2.   private int tickets = 100;
    3.   //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    4.   @Override
    5.   public void run() {
    6.       while (true) {
    7.           if(ticket <= 0){
    8.                   //卖完了
    9.                   break;
    10.               }else{
    11.                   try {
    12.                       Thread.sleep(100);
    13.                   } catch (InterruptedException e) {
    14.                       e.printStackTrace();
    15.                   }
    16.                   ticket--;
    17.                   System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
    18.               }
    19.       }
    20.   }
    21. }
    22. public class SellTicketDemo {
    23.   public static void main(String[] args) {
    24.       //创建SellTicket类的对象
    25.       SellTicket st = new SellTicket();
    27.       //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
    28.       Thread t1 = new Thread(st,"窗口1");
    29.       Thread t2 = new Thread(st,"窗口2");
    30.       Thread t3 = new Thread(st,"窗口3");
    32.       //启动线程
    33.       t1.start();
    34.       t2.start();
    35.       t3.start();
    36.   }
    37. }

2.2 卖票案例的问题【理解】

  • 卖票出现了问题
    • 相同的票出现了多次
    • 出现了负数的票
  • 问题产生原因
    线程执行的随机性导致的

2.3 数据安全问题-同步代码块【应用】

  • 安全问题出现的条件
    • 是多线程环境
    • 有共享数据
    • 有多条语句操作共享数据
  • 如何解决多线程安全问题呢?
    • 基本思想：让程序没有安全问题的环境
  • 怎么实现呢?
    • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
    • Java提供了同步代码块的方式来解决

  • 同步代码块格式：

    1. synchronized(任意对象) { 
    2.   多条语句操作共享数据的代码 
    3. }

  • synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

  • 同步的好处和弊端
    • 好处：解决了多线程的数据安全问题
    • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

  • 代码演示 ```java public class SellTicket implements Runnable { private int tickets = 100; private Object obj = new Object();

    @Override public void run() {

    1.   while (true) {
    2.       synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
    3.           //t1进来后，就会把这段代码给锁起来
    4.           if (tickets > 0) {
    5.               try {
    6.                   Thread.sleep(100);
    7.                   //t1休息100毫秒
    8.               } catch (InterruptedException e) {
    9.                   e.printStackTrace();
    10.               }
    11.               //窗口1正在出售第100张票
    12.               System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
    13.               tickets--; //tickets = 99;
    14.           }
    15.       }
    16.       //t1出来了，这段代码的锁就被释放了
    17.   }

    } }

public class SellTicketDemo { public static void main(String[] args) { SellTicket st = new SellTicket();

  1.     Thread t1 = new Thread(st, "窗口1");
  2.     Thread t2 = new Thread(st, "窗口2");
  3.     Thread t3 = new Thread(st, "窗口3");
  5.     t1.start();
  6.     t2.start();
  7.     t3.start();
  8. }

}

  2. <a name="75fd4c8d"></a>
  3. ### 2.4 数据安全问题-锁对象唯一 【应用】
  5. - 锁对象的注意事项
  6.    - 锁对象可以是任意对象
  7.    - 多个线程要想保证安全,必须使用同一把锁对象
  8. - 示例代码
  9. ```java
  10. /**
  11.  * 锁唯一
  12.  */
  13. public class MainClass {
  14.     public static void main(String[] args) {
  15.         MyThread ticket1 = new MyThread();
  16.         MyThread ticket2 = new MyThread();
  17.         ticket1.setName("窗口1");
  18.         ticket2.setName("窗口2");
  20.         ticket1.start();
  21.         ticket2.start();
  22.     }
  23. }
  25. class MyThread extends Thread {
  26.     private static int ticketCount = 100;
  27.     private static Object lock = new Object();
  29.     @Override
  30.     public void run() {
  31.         while (true) {
  32.             synchronized (lock) {
  33.                 if (ticketCount > 0) {
  34.                     ticketCount--;
  35.                     try {
  36.                         Thread.sleep(100);
  37.                     } catch (InterruptedException e) {
  38.                         e.printStackTrace();
  39.                     }
  40.                     System.out.println(getName() + "在卖票,还剩下" + ticketCount + "张票");
  41.                 }
  42.             }
  43.         }
  44.     }
  45. }

2.5 同步方法解决数据安全问题【应用】

  • 同步方法的格式
    同步方法：就是把synchronized关键字加到方法上

    1. 修饰符 synchronized 返回值类型 方法名(方法参数) { 
    2.   方法体；
    3. }

  • 同步方法的锁对象是什么呢?
    this

  • 静态同步方法
    同步静态方法：就是把synchronized关键字加到静态方法上

    1. 修饰符 static synchronized 返回值类型 方法名(方法参数) { 
    2.   方法体；
    3. }

  • 同步静态方法的锁对象是什么呢?
    类名.class

  • 代码演示 ```java public class MyRunnable implements Runnable { private static int ticketCount = 100;

    @Override public void run() {

    1.   while(true){
    2.       if("窗口一".equals(Thread.currentThread().getName())){
    3.           //同步方法
    4.           boolean result = synchronizedMthod();
    5.           if(result){
    6.               break;
    7.           }
    8.       }
    10.       if("窗口二".equals(Thread.currentThread().getName())){
    11.           //同步代码块
    12.           synchronized (MyRunnable.class){
    13.               if(ticketCount == 0){
    14.                  break;
    15.               }else{
    16.                   try {
    17.                       Thread.sleep(10);
    18.                   } catch (InterruptedException e) {
    19.                       e.printStackTrace();
    20.                   }
    21.                   ticketCount--;
    22.                   System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
    23.               }
    24.           }
    25.       }
    27.   }

    }

    private static synchronized boolean synchronizedMthod() {

    1.   if(ticketCount == 0){
    2.       return true;
    3.   }else{
    4.       try {
    5.           Thread.sleep(10);
    6.       } catch (InterruptedException e) {
    7.           e.printStackTrace();
    8.       }
    9.       ticketCount--;
    10.       System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
    11.       return false;
    12.   }

    } }

public class Demo { public static void main(String[] args) { MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr); Thread t2 = new Thread(mr);

  1.       t1.setName("窗口一");
  2.       t2.setName("窗口二");
  4.       t1.start();
  5.       t2.start();

} }

  2. <a name="4a968cac"></a>
  3. ### 2.6 Lock锁【应用】
  5. - 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
  6. - Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
  7. - Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
  9. - ReentrantLock构造方法
  10. | 方法名 | 说明 |
  11. | --- | --- |
  12. | ReentrantLock() | 创建一个ReentrantLock的实例 |
  14. - 加锁解锁方法
  15. | 方法名 | 说明 |
  16. | --- | --- |
  17. | void lock() | 获得锁 |
  18. | void unlock() | 释放锁 |
  20. - 代码演示
  21. ```java
  22.   public class Ticket implements Runnable {
  23.       //票的数量
  24.       private int ticket = 100;
  25.       private Object obj = new Object();
  26.       private ReentrantLock lock = new ReentrantLock();
  28.       @Override
  29.       public void run() {
  30.           while (true) {
  31.               //synchronized (obj){//多个线程必须使用同一把锁.
  32.               try {
  33.                   lock.lock();
  34.                   if (ticket <= 0) {
  35.                       //卖完了
  36.                       break;
  37.                   } else {
  38.                       Thread.sleep(100);
  39.                       ticket--;
  40.                       System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
  41.                   }
  42.               } catch (InterruptedException e) {
  43.                   e.printStackTrace();
  44.               } finally {
  45.                   lock.unlock();
  46.               }
  47.               // }
  48.           }
  49.       }
  50.   }
  52.   public class Demo {
  53.       public static void main(String[] args) {
  54.           Ticket ticket = new Ticket();
  56.           Thread t1 = new Thread(ticket);
  57.           Thread t2 = new Thread(ticket);
  58.           Thread t3 = new Thread(ticket);
  60.           t1.setName("窗口一");
  61.           t2.setName("窗口二");
  62.           t3.setName("窗口三");
  64.           t1.start();
  65.           t2.start();
  66.           t3.start();
  67.       }
  68.   }

2.7 死锁【理解】

  • 概述
    线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
  • 什么情况下会产生死锁
    1. 资源有限
    2. 同步嵌套

  • 代码演示

    1. public class Demo {
    2.   public static void main(String[] args) {
    3.       Object objA = new Object();
    4.       Object objB = new Object();
    6.       new Thread(()->{
    7.           while(true){
    8.               synchronized (objA){
    9.                   //线程一
    10.                   synchronized (objB){
    11.                       System.out.println("小康同学正在走路");
    12.                   }
    13.               }
    14.           }
    15.       }).start();
    17.       new Thread(()->{
    18.           while(true){
    19.               synchronized (objB){
    20.                   //线程二
    21.                   synchronized (objA){
    22.                       System.out.println("小薇同学正在走路");
    23.                   }
    24.               }
    25.           }
    26.       }).start();
    27.   }
    28. }

3.生产者消费者

3.1 生产者和消费者模式概述【应用】

  • 概述
    生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
    所谓生产者消费者问题，实际上主要是包含了两类线程：
    一类是生产者线程用于生产数据
    一类是消费者线程用于消费数据
    为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
    生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
    消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
  • Object类的等待和唤醒方法 | 方法名 | 说明 | | —- | —- | | void wait() | 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 | | void notify() | 唤醒正在等待对象监视器的单个线程 | | void notifyAll() | 唤醒正在等待对象监视器的所有线程 |

3.2 生产者和消费者案例【应用】

  • 案例需求
    • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
    • 生产者类(Cooker)：继承Thread类，重写run()方法，设置线程任务
      1.判断是否有包子,决定当前线程是否执行
      2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
      3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子
    • 消费者类(Foodie)：继承Thread类，重写run()方法，设置线程任务
      1.判断是否有包子,决定当前线程是否执行
      2.如果没有包子,就进入等待状态,如果有包子,就消费包子
      3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子
    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下
      创建生产者线程和消费者线程对象
      分别开启两个线程

  • 代码实现 ```java public class Desk {

    //定义一个标记 //true 就表示桌子上有汉堡包的,此时允许吃货执行 //false 就表示桌子上没有汉堡包的,此时允许厨师执行 public static boolean flag = false;

    //汉堡包的总数量 public static int count = 10;

    //锁对象 public static final Object lock = new Object(); }

public class Cooker extends Thread { // 生产者步骤： // 1，判断桌子上是否有汉堡包 // 如果有就等待，如果没有才生产。 // 2，把汉堡包放在桌子上。 // 3，叫醒等待的消费者开吃。 @Override public void run() { while(true){ synchronized (Desk.lock){ if(Desk.count == 0){ break; }else{ if(!Desk.flag){ //生产 System.out.println(“厨师正在生产汉堡包”); Desk.flag = true; Desk.lock.notifyAll(); }else{ try { Desk.lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } } }

public class Foodie extends Thread { @Override public void run() { // 1，判断桌子上是否有汉堡包。 // 2，如果没有就等待。 // 3，如果有就开吃 // 4，吃完之后，桌子上的汉堡包就没有了 // 叫醒等待的生产者继续生产 // 汉堡包的总数量减一

  1.     //套路:
  2.         //1. while(true)死循环
  3.         //2. synchronized 锁,锁对象要唯一
  4.         //3. 判断,共享数据是否结束. 结束
  5.         //4. 判断,共享数据是否结束. 没有结束
  6.     while(true){
  7.         synchronized (Desk.lock){
  8.             if(Desk.count == 0){
  9.                 break;
  10.             }else{
  11.                 if(Desk.flag){
  12.                     //有
  13.                     System.out.println("吃货在吃汉堡包");
  14.                     Desk.flag = false;
  15.                     Desk.lock.notifyAll();
  16.                     Desk.count--;
  17.                 }else{
  18.                     //没有就等待
  19.                     //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
  20.                     try {
  21.                         Desk.lock.wait();
  22.                     } catch (InterruptedException e) {
  23.                         e.printStackTrace();
  24.                     }
  25.                 }
  26.             }
  27.         }
  28.     }
  29. }

}

public class Demo { public static void main(String[] args) { /消费者步骤： 1，判断桌子上是否有汉堡包。 2，如果没有就等待。 3，如果有就开吃 4，吃完之后，桌子上的汉堡包就没有了 叫醒等待的生产者继续生产 汉堡包的总数量减一/

  1.     /*生产者步骤：
  2.     1，判断桌子上是否有汉堡包
  3.     如果有就等待，如果没有才生产。
  4.     2，把汉堡包放在桌子上。
  5.     3，叫醒等待的消费者开吃。*/
  7.     Foodie f = new Foodie();
  8.     Cooker c = new Cooker();
  10.     f.start();
  11.     c.start();
  12. }

}

  2. <a name="02aa8418"></a>
  3. ### 3.3 生产者和消费者案例优化【应用】
  5. - 需求
  6.    - 将Desk类中的变量,采用面向对象的方式封装起来
  7.    - 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用
  8.    - 创建生产者和消费者线程对象,构造方法中传入Desk类对象
  9.    - 开启两个线程
  10. - 代码实现
  11. ```java
  12. public class Desk {
  14.     //定义一个标记
  15.     //true 就表示桌子上有汉堡包的,此时允许吃货执行
  16.     //false 就表示桌子上没有汉堡包的,此时允许厨师执行
  17.     //public static boolean flag = false;
  18.     private boolean flag;
  20.     //汉堡包的总数量
  21.     //public static int count = 10;
  22.     //以后我们在使用这种必须有默认值的变量
  23.    // private int count = 10;
  24.     private int count;
  26.     //锁对象
  27.     //public static final Object lock = new Object();
  28.     private final Object lock = new Object();
  30.     public Desk() {
  31.         this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
  32.     }
  34.     public Desk(boolean flag, int count) {
  35.         this.flag = flag;
  36.         this.count = count;
  37.     }
  39.     public boolean isFlag() {
  40.         return flag;
  41.     }
  43.     public void setFlag(boolean flag) {
  44.         this.flag = flag;
  45.     }
  47.     public int getCount() {
  48.         return count;
  49.     }
  51.     public void setCount(int count) {
  52.         this.count = count;
  53.     }
  55.     public Object getLock() {
  56.         return lock;
  57.     }
  59.     @Override
  60.     public String toString() {
  61.         return "Desk{" +
  62.                 "flag=" + flag +
  63.                 ", count=" + count +
  64.                 ", lock=" + lock +
  65.                 '}';
  66.     }
  67. }
  69. public class Cooker extends Thread {
  71.     private Desk desk;
  73.     public Cooker(Desk desk) {
  74.         this.desk = desk;
  75.     }
  76. //    生产者步骤：
  77. //            1，判断桌子上是否有汉堡包
  78. //    如果有就等待，如果没有才生产。
  79. //            2，把汉堡包放在桌子上。
  80. //            3，叫醒等待的消费者开吃。
  82.     @Override
  83.     public void run() {
  84.         while(true){
  85.             synchronized (desk.getLock()){
  86.                 if(desk.getCount() == 0){
  87.                     break;
  88.                 }else{
  89.                     //System.out.println("验证一下是否执行了");
  90.                     if(!desk.isFlag()){
  91.                         //生产
  92.                         System.out.println("厨师正在生产汉堡包");
  93.                         desk.setFlag(true);
  94.                         desk.getLock().notifyAll();
  95.                     }else{
  96.                         try {
  97.                             desk.getLock().wait();
  98.                         } catch (InterruptedException e) {
  99.                             e.printStackTrace();
  100.                         }
  101.                     }
  102.                 }
  103.             }
  104.         }
  105.     }
  106. }
  108. public class Foodie extends Thread {
  109.     private Desk desk;
  111.     public Foodie(Desk desk) {
  112.         this.desk = desk;
  113.     }
  115.     @Override
  116.     public void run() {
  117. //        1，判断桌子上是否有汉堡包。
  118. //        2，如果没有就等待。
  119. //        3，如果有就开吃
  120. //        4，吃完之后，桌子上的汉堡包就没有了
  121. //                叫醒等待的生产者继续生产
  122. //        汉堡包的总数量减一
  124.         //套路:
  125.             //1. while(true)死循环
  126.             //2. synchronized 锁,锁对象要唯一
  127.             //3. 判断,共享数据是否结束. 结束
  128.             //4. 判断,共享数据是否结束. 没有结束
  129.         while(true){
  130.             synchronized (desk.getLock()){
  131.                 if(desk.getCount() == 0){
  132.                     break;
  133.                 }else{
  134.                     //System.out.println("验证一下是否执行了");
  135.                     if(desk.isFlag()){
  136.                         //有
  137.                         System.out.println("吃货在吃汉堡包");
  138.                         desk.setFlag(false);
  139.                         desk.getLock().notifyAll();
  140.                         desk.setCount(desk.getCount() - 1);
  141.                     }else{
  142.                         //没有就等待
  143.                         //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
  144.                         try {
  145.                             desk.getLock().wait();
  146.                         } catch (InterruptedException e) {
  147.                             e.printStackTrace();
  148.                         }
  149.                     }
  150.                 }
  151.             }
  152.         }
  154.     }
  155. }
  157. public class Demo {
  158.     public static void main(String[] args) {
  159.         /*消费者步骤：
  160.         1，判断桌子上是否有汉堡包。
  161.         2，如果没有就等待。
  162.         3，如果有就开吃
  163.         4，吃完之后，桌子上的汉堡包就没有了
  164.                 叫醒等待的生产者继续生产
  165.         汉堡包的总数量减一*/
  167.         /*生产者步骤：
  168.         1，判断桌子上是否有汉堡包
  169.         如果有就等待，如果没有才生产。
  170.         2，把汉堡包放在桌子上。
  171.         3，叫醒等待的消费者开吃。*/
  173.         Desk desk = new Desk();
  175.         Foodie f = new Foodie(desk);
  176.         Cooker c = new Cooker(desk);
  178.         f.start();
  179.         c.start();
  181.     }
  182. }

3.4 阻塞队列基本使用【理解】

  • 阻塞队列继承结构
    06_阻塞队列继承结构.png
  • 常见BlockingQueue:
    ArrayBlockingQueue: 底层是数组,有界
    LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值
  • BlockingQueue的核心方法:
    put(anObject): 将参数放入队列,如果放不进去会阻塞
    take(): 取出第一个数据,取不到会阻塞

  • 代码示例

    1. public class Demo02 {
    2.   public static void main(String[] args) throws Exception {
    3.       // 创建阻塞队列的对象,容量为 1
    4.       ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
    6.       // 存储元素
    7.       arrayBlockingQueue.put("汉堡包");
    8.       arrayBlockingQueue.put("汉堡包");
    10.       // 取元素
    11.       System.out.println(arrayBlockingQueue.take());
    12.       System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞
    14.       System.out.println("程序结束了");
    15.   }
    16. }

3.5 阻塞队列实现等待唤醒机制【理解】

  • 案例需求
    • 生产者类(Cooker)：继承Thread类，重写run()方法，设置线程任务
      1.构造方法中接收一个阻塞队列对象
      2.在run方法中循环向阻塞队列中添加包子
      3.打印添加结果
    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
      1.构造方法中接收一个阻塞队列对象
      2.在run方法中循环获取阻塞队列中的包子
      3.打印获取结果
    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下
      创建阻塞队列对象
      创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象
      分别开启两个线程

  • 代码实现 ```java public class Cooker extends Thread {

    private ArrayBlockingQueue bd;

    public Cooker(ArrayBlockingQueue bd) {

    1.   this.bd = bd;

    } // 生产者步骤： // 1，判断桌子上是否有汉堡包 // 如果有就等待，如果没有才生产。 // 2，把汉堡包放在桌子上。 // 3，叫醒等待的消费者开吃。

    @Override public void run() {

    1.   while (true) {
    2.       try {
    3.           bd.put("汉堡包");
    4.           System.out.println("厨师放入一个汉堡包");
    5.       } catch (InterruptedException e) {
    6.           e.printStackTrace();
    7.       }
    8.   }

    } }

public class Foodie extends Thread { private ArrayBlockingQueue bd;

  1. public Foodie(ArrayBlockingQueue<String> bd) {
  2.     this.bd = bd;
  3. }
  5. @Override
  6. public void run() {

// 1，判断桌子上是否有汉堡包。 // 2，如果没有就等待。 // 3，如果有就开吃 // 4，吃完之后，桌子上的汉堡包就没有了 // 叫醒等待的生产者继续生产 // 汉堡包的总数量减一

  1.     //套路:
  2.     //1. while(true)死循环
  3.     //2. synchronized 锁,锁对象要唯一
  4.     //3. 判断,共享数据是否结束. 结束
  5.     //4. 判断,共享数据是否结束. 没有结束
  6.     while (true) {
  7.         try {
  8.             String take = bd.take();
  9.             System.out.println("吃货将" + take + "拿出来吃了");
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  15. }

}

public class Demo { public static void main(String[] args) { ArrayBlockingQueue bd = new ArrayBlockingQueue<>(1);

  1.     Foodie f = new Foodie(bd);
  2.     Cooker c = new Cooker(bd);
  4.     f.start();
  5.     c.start();
  6. }

}

  2. <a name="d5ae024b"></a>
  3. ## 4.线程池
  5. <a name="a2373464"></a>
  6. ### 4.1 线程状态介绍
  8. 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？
  10. Java中的线程状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：
  12. ```java
  13. public class Thread {
  15.     public enum State {
  17.         /* 新建 */
  18.         NEW , 
  20.         /* 可运行状态 */
  21.         RUNNABLE , 
  23.         /* 阻塞状态 */
  24.         BLOCKED , 
  26.         /* 无限等待状态 */
  27.         WAITING , 
  29.         /* 计时等待 */
  30.         TIMED_WAITING , 
  32.         /* 终止 */
  33.         TERMINATED;
  35.     }
  37.     // 获取当前线程的状态
  38.     public State getState() {
  39.         return jdk.internal.misc.VM.toThreadState(threadStatus);
  40.     }
  42. }

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

线程状态 具体含义
NEW 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED 一个完全运行完成的线程的状态。也称之为终止状态、结束状态

各个状态的转换，如下图所示：

1591163781941.png

4.2 线程池-基本原理

概述 :

  1. 提到池，大家应该能想到的就是水池。水池就是一个容器，在该容器中存储了很多的水。那么什么是线程池呢？线程池也是可以看做成一个池子，在该池子中存储很多个线程。

线程池存在的意义：

  1. 线程的创建和销毁的开销是巨大的，而通过线程池的重用性，大大减少了这些不必要的资源开销。

线程池的设计思路 :

  1. 创建一个池子，池子是空的
  2. 有任务需要执行时，才会创建线程对象，当任务执行完毕，线程对象归还给池子。
  3. 再次有新的任务，则直接从池子中获取线程去执行任务。

4.3 线程池-Executors默认线程池

概述 :

  1. JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。
  3. 我们可以使用Executors中所提供的**静态**方法来创建线程池
方法名 描述
static newCachedThreadPool() 创建一个默认的线程池
static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池

代码实现 :

  1. package com.itheima.mythreadpool;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  6. public class MyThreadPoolDemo {
  7.     public static void main(String[] args) throws InterruptedException {
  9.         //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
  10.         ExecutorService executorService = Executors.newCachedThreadPool();
  11.         //Executors --- 可以帮助我们创建线程池对象
  12.         //ExecutorService --- 可以帮助我们控制线程池
  13.         new Thread()
  14.         executorService.submit(()->{
  15.             System.out.println(Thread.currentThread().getName() + "在执行了");
  16.         });
  18.         //Thread.sleep(2000);
  20.         executorService.submit(()->{
  21.             System.out.println(Thread.currentThread().getName() + "在执行了");
  22.         });
  24.         executorService.shutdown();
  25.     }
  26. }

4.4 线程池-Executors创建指定上限的线程池

使用Executors中所提供的静态方法newFixedThreadPool来创建指定上限线程池

注意事项：

  • 默认线程池中的线程个数为0
  • 参数不是初始值，是最大值

代码实现 :

  1. package com.itheima.mythreadpool;
  2. //创建一个指定最多线程数量的线程池
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.ThreadPoolExecutor;
  8. public class MyThreadPoolDemo2 {
  9.     public static void main(String[] args) {
  10.         //参数不是初始值而是最大值
  11.         ExecutorService executorService = Executors.newFixedThreadPool(10);
  13.         ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
  14.         System.out.println(pool.getPoolSize());//0
  16.         executorService.submit(()->{
  17.             System.out.println(Thread.currentThread().getName() + "在执行了");
  18.         });
  20.         executorService.submit(()->{
  21.             System.out.println(Thread.currentThread().getName() + "在执行了");
  22.         });
  24.         System.out.println(pool.getPoolSize());//2
  25. //        executorService.shutdown();
  26.     }
  27. }

4.5 线程池-ThreadPoolExecutor

创建线程池对象 :

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

1591165506516.png

代码实现 :

  1. package com.itheima.mythreadpool;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.Executors;
  5. import java.util.concurrent.ThreadPoolExecutor;
  6. import java.util.concurrent.TimeUnit;
  8. public class MyThreadPoolDemo3 {
  9. //    参数一：核心线程数量
  10. //    参数二：最大线程数
  11. //    参数三：空闲线程最大存活时间
  12. //    参数四：时间单位
  13. //    参数五：任务队列
  14. //    参数六：创建线程工厂
  15. //    参数七：任务的拒绝策略
  16.     public static void main(String[] args) {
  17.         ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
  18.         pool.submit(new MyRunnable());
  19.         pool.submit(new MyRunnable());
  21.         pool.shutdown();
  22.     }
  23. }

4.6 线程池-参数详解

  • 参数详解
    • corePoolSize： 核心线程的最大值，不能小于0
    • maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize
    • keepAliveTime： 空闲线程最大存活时间,不能小于0
    • unit：时间单位
    • workQueue： 任务队列，不能为null
    • threadFactory： 创建线程工厂,不能为null
    • handler： 任务的拒绝策略,不能为null
  • 任务拒绝策略的触发时机：提交的任务 > 线程池的最大线程数 + 队列容量
  • 默认任务拒绝策略会抛出异常

4.7 线程池-任务拒绝策略

  • RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。 | 拒绝策略 | | | —- | —- | | ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 | | ThreadPoolExecutor.DiscardPolicy | 丢弃任务，但是不抛出异常，这是不推荐的做法 | | ThreadPoolExecutor.DiscardOldestPolicy | 抛弃队列中等待最久的任务 然后把当前任务加入队列中 | | ThreadPoolExecutor.CallerRunsPolicy | 调用任务的run()方法绕过线程池直接执行 |

案例演示1：演示ThreadPoolExecutor.AbortPolicy任务处理策略

  1. public class ThreadPoolExecutorDemo01 {
  3.     public static void main(String[] args) {
  5.         /**
  6.          * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
  7.          */
  8.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
  9.             1 , 
  10.             3 ,
  11.             20 ,
  12.             TimeUnit.SECONDS ,
  13.             new ArrayBlockingQueue<>(1) , 
  14.             Executors.defaultThreadFactory() , 
  15.             new ThreadPoolExecutor.AbortPolicy()) ;
  16.         // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
  17.         for(int x = 0 ; x < 5 ; x++) {
  18.             threadPoolExecutor.submit(() -> {
  19.                 System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
  20.             });
  21.         }
  22.     }
  23. }

控制台输出结果

  1. pool-1-thread-1---->> 执行了任务
  2. pool-1-thread-3---->> 执行了任务
  3. pool-1-thread-2---->> 执行了任务
  4. pool-1-thread-3---->> 执行了任务

控制台报错，仅仅执行了4个任务，有一个任务被丢弃了

案例演示2：演示ThreadPoolExecutor.DiscardPolicy任务处理策略

  1. public class ThreadPoolExecutorDemo02 {
  2.     public static void main(String[] args) {
  3.         /**
  4.          * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
  5.          */
  6.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
  7.             1 ,
  8.             3 , 
  9.             20 , 
  10.             TimeUnit.SECONDS ,
  11.             new ArrayBlockingQueue<>(1) , 
  12.             Executors.defaultThreadFactory() ,
  13.             new ThreadPoolExecutor.DiscardPolicy()) ;
  14.         // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错
  15.         for(int x = 0 ; x < 5 ; x++) {
  16.             threadPoolExecutor.submit(() -> {
  17.                 System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
  18.             });
  19.         }
  20.     }
  21. }

控制台输出结果

  1. pool-1-thread-1---->> 执行了任务
  2. pool-1-thread-1---->> 执行了任务
  3. pool-1-thread-3---->> 执行了任务
  4. pool-1-thread-2---->> 执行了任务

控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了

案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略

  1. public class ThreadPoolExecutorDemo02 {
  2.     public static void main(String[] args) {
  3.         /**
  4.          * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
  5.          */
  6.         ThreadPoolExecutor threadPoolExecutor;
  7.         threadPoolExecutor = new ThreadPoolExecutor(
  8.             1 , 
  9.             3 , 
  10.             20 , 
  11.             TimeUnit.SECONDS ,
  12.             new ArrayBlockingQueue<>(1) , 
  13.             Executors.defaultThreadFactory() , 
  14.             new ThreadPoolExecutor.DiscardOldestPolicy());
  15.         // 提交5个任务
  16.         for(int x = 0 ; x < 5 ; x++) {
  17.             // 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰
  18.             final int y = x ;
  19.             threadPoolExecutor.submit(() -> {
  20.                 System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y);
  21.             });     
  22.         }
  23.     }
  24. }

控制台输出结果

  1. pool-1-thread-2---->> 执行了任务2
  2. pool-1-thread-1---->> 执行了任务0
  3. pool-1-thread-3---->> 执行了任务3
  4. pool-1-thread-1---->> 执行了任务4

由于任务1在线程池中等待时间最长，因此任务1被丢弃。

案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略

  1. public class ThreadPoolExecutorDemo04 {
  2.     public static void main(String[] args) {
  4.         /**
  5.          * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
  6.          */
  7.         ThreadPoolExecutor threadPoolExecutor;
  8.         threadPoolExecutor = new ThreadPoolExecutor(
  9.             1 , 
  10.             3 , 
  11.             20 , 
  12.             TimeUnit.SECONDS ,
  13.             new ArrayBlockingQueue<>(1) , 
  14.             Executors.defaultThreadFactory() , 
  15.             new ThreadPoolExecutor.CallerRunsPolicy());
  16.         // 提交5个任务
  17.         for(int x = 0 ; x < 5 ; x++) {
  18.             threadPoolExecutor.submit(() -> {
  19.                 System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
  20.             });
  21.         }
  22.     }
  23. }

控制台输出结果

  1. pool-1-thread-1---->> 执行了任务
  2. pool-1-thread-3---->> 执行了任务
  3. pool-1-thread-2---->> 执行了任务
  4. pool-1-thread-1---->> 执行了任务
  5. main---->> 执行了任务

通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。

5. 原子性

5.1 volatile-问题

代码分析 :

  1. package com.itheima.myvolatile;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         MyThread1 t1 = new MyThread1();
  6.         t1.setName("小路同学");
  7.         t1.start();
  9.         MyThread2 t2 = new MyThread2();
  10.         t2.setName("小皮同学");
  11.         t2.start();
  12.     }
  13. }
  1. package com.itheima.myvolatile;
  3. public class Money {
  4.     public static int money = 100000;
  5. }
  1. package com.itheima.myvolatile;
  3. public class MyThread1 extends  Thread {
  4.     @Override
  5.     public void run() {
  6.         while(Money.money == 100000){
  8.         }
  10.         System.out.println("结婚基金已经不是十万了");
  11.     }
  12. }
  1. package com.itheima.myvolatile;
  3. public class MyThread2 extends Thread {
  4.     @Override
  5.     public void run() {
  6.         try {
  7.             Thread.sleep(10);
  8.         } catch (InterruptedException e) {
  9.             e.printStackTrace();
  10.         }
  12.         Money.money = 90000;
  13.     }
  14. }

程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。

5.2 volatile解决

以上案例出现的问题 :

  1. 当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题
  3. 1，堆内存是唯一的，每一个线程都有自己的线程栈。
  5. 2 ，每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。
  7. 3 ，在线程中，每一次使用是从变量的副本中获取的。

Volatile关键字 : 强制线程每次在使用的时候，都会看一下共享区域最新的值

代码实现 : 使用volatile关键字解决

  1. package com.itheima.myvolatile;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         MyThread1 t1 = new MyThread1();
  6.         t1.setName("小路同学");
  7.         t1.start();
  9.         MyThread2 t2 = new MyThread2();
  10.         t2.setName("小皮同学");
  11.         t2.start();
  12.     }
  13. }
  1. package com.itheima.myvolatile;
  3. public class Money {
  4.     public static volatile int money = 100000;
  5. }
  1. package com.itheima.myvolatile;
  3. public class MyThread1 extends  Thread {
  4.     @Override
  5.     public void run() {
  6.         while(Money.money == 100000){
  8.         }
  9.         System.out.println("结婚基金已经不是十万了");
  10.     }
  11. }
  1. package com.itheima.myvolatile;
  3. public class MyThread2 extends Thread {
  4.     @Override
  5.     public void run() {
  6.         try {
  7.             Thread.sleep(10);
  8.         } catch (InterruptedException e) {
  9.             e.printStackTrace();
  10.         }
  11.         Money.money = 90000;
  12.     }
  13. }

5.3 synchronized解决

synchronized解决 :

  1. 1 、线程获得锁
  3. 2 、清空变量副本
  5. 3 、拷贝共享变量最新的值到变量副本中
  7. 4 、执行代码
  9. 5 、将修改后变量副本中的值赋值给共享数据
  11. 6 、释放锁

代码实现 :

  1. package com.itheima.myvolatile2;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         MyThread1 t1 = new MyThread1();
  6.         t1.setName("小路同学");
  7.         t1.start();
  9.         MyThread2 t2 = new MyThread2();
  10.         t2.setName("小皮同学");
  11.         t2.start();
  12.     }
  13. }
  1. package com.itheima.myvolatile2;
  3. public class Money {
  4.     public static Object lock = new Object();
  5.     public static int money = 100000;
  6. }
  1. package com.itheima.myvolatile2;
  3. public class MyThread1 extends Thread {
  4.     @Override
  5.     public void run() {
  6.         while(true){
  7.             synchronized (Money.lock){
  8.                 if(Money.money != 100000){
  9.                     System.out.println("结婚基金已经不是十万了");
  10.                     break;
  11.                 }
  12.             }
  13.         }
  14.     }
  15. }
  1. package com.itheima.myvolatile2;
  3. public class MyThread2 extends Thread {
  4.     @Override
  5.     public void run() {
  6.         synchronized (Money.lock) {
  7.             try {
  8.                 Thread.sleep(10);
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  13.             Money.money = 90000;
  14.         }
  15.     }
  16. }

5.4 原子性

概述 :

所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

2020-08-23_205105.png

代码实现 :

  1. package com.itheima.threadatom;
  3. public class AtomDemo {
  4.     public static void main(String[] args) {
  5.         MyAtomThread atom = new MyAtomThread();
  7.         for (int i = 0; i < 100; i++) {
  8.             new Thread(atom).start();
  9.         }
  10.     }
  11. }
  12. class MyAtomThread implements Runnable {
  13.     private volatile int count = 0; //送冰淇淋的数量
  15.     @Override
  16.     public void run() {
  17.         for (int i = 0; i < 100; i++) {
  18.             //1,从共享数据中读取数据到本线程栈中.
  19.             //2,修改本线程栈中变量副本的值
  20.             //3,会把本线程栈中变量副本的值赋值给共享数据.
  21.             count++;
  22.             System.out.println("已经送了" + count + "个冰淇淋");
  23.         }
  24.     }
  25. }

代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断

5.5 volatile关键字不能保证原子性

  • volatile关键字：
    • 只能保证线程每次在使用共享数据的时候是最新值。
    • 但是不能保证原子性。
  • 解决方案 :
    • 我们可以给count操作添加锁，那么count操作就是临界区中的代码，临界区中的代码一次只能被一个线程去执行，所以count++就变成了原子操作。
  1. package com.itheima.threadatom2;
  3. public class AtomDemo {
  4.     public static void main(String[] args) {
  5.         MyAtomThread atom = new MyAtomThread();
  7.         for (int i = 0; i < 100; i++) {
  8.             new Thread(atom).start();
  9.         }
  10.     }
  11. }
  12. class MyAtomThread implements Runnable {
  13.     private volatile int count = 0; //送冰淇淋的数量
  14.     private Object lock = new Object();
  16.     @Override
  17.     public void run() {
  18.         for (int i = 0; i < 100; i++) {
  19.             //1,从共享数据中读取数据到本线程栈中.
  20.             //2,修改本线程栈中变量副本的值
  21.             //3,会把本线程栈中变量副本的值赋值给共享数据.
  22.             synchronized (lock) {
  23.                 count++;
  24.                 System.out.println("已经送了" + count + "个冰淇淋");
  25.             }
  26.         }
  27.     }
  28. }

5.6 原子性_AtomicInteger

概述：

java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。

本次我们只讲解使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：

AtomicBoolean： 原子更新布尔类型

AtomicInteger： 原子更新整型

AtomicLong： 原子更新长整型

AtomicInteger的常用方法如下：

方法名
AtomicInteger() 初始化一个默认值为0的原子型Integer
AtomicInteger(int initialValue) 初始化一个指定值的原子型Integer
int get() 获取值
int getAndIncrement() 以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet() 以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data) 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value) 以原子方式设置为newValue的值，并返回旧值。

代码实现 :

  1. package com.itheima.threadatom3;
  3. import java.util.concurrent.atomic.AtomicInteger;
  5. public class MyAtomIntergerDemo1 {
  6. //    public AtomicInteger()：                  初始化一个默认值为0的原子型Integer
  7. //    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
  8.     public static void main(String[] args) {
  9.         AtomicInteger ac = new AtomicInteger();
  10.         System.out.println(ac);
  12.         AtomicInteger ac2 = new AtomicInteger(10);
  13.         System.out.println(ac2);
  14.     }
  16. }
  1. package com.itheima.threadatom3;
  3. import java.lang.reflect.Field;
  4. import java.util.concurrent.atomic.AtomicInteger;
  6. public class MyAtomIntergerDemo2 {
  7. //    int get():                    获取值
  8. //    int getAndIncrement():     以原子方式将当前值加1，注意，这里返回的是自增前的值。
  9. //    int incrementAndGet():     以原子方式将当前值加1，注意，这里返回的是自增后的值。
  10. //    int addAndGet(int data):     以原子方式将参数与对象中的值相加，并返回结果。
  11. //    int getAndSet(int value):  以原子方式设置为newValue的值，并返回旧值。
  12.     public static void main(String[] args) {
  13. //        AtomicInteger ac1 = new AtomicInteger(10);
  14. //        System.out.println(ac1.get());
  16. //        AtomicInteger ac2 = new AtomicInteger(10);
  17. //        int andIncrement = ac2.getAndIncrement();
  18. //        System.out.println(andIncrement);
  19. //        System.out.println(ac2.get());
  21. //        AtomicInteger ac3 = new AtomicInteger(10);
  22. //        int i = ac3.incrementAndGet();
  23. //        System.out.println(i);//自增后的值
  24. //        System.out.println(ac3.get());
  26. //        AtomicInteger ac4 = new AtomicInteger(10);
  27. //        int i = ac4.addAndGet(20);
  28. //        System.out.println(i);
  29. //        System.out.println(ac4.get());
  31.         AtomicInteger ac5 = new AtomicInteger(100);
  32.         int andSet = ac5.getAndSet(20);
  33.         System.out.println(andSet);
  34.         System.out.println(ac5.get());
  35.     }
  36. }

5.7 AtomicInteger-内存解析

AtomicInteger原理 :

  1. 自旋锁  + CAS 算法

CAS算法：有3个操作数（内存值V， 旧的预期值A，要修改的值B）

  • 当旧的预期值A == 内存值 此时修改成功，将V改为B2020-08-23_212737.png
  • 当旧的预期值A！=内存值 此时修改失败，不做任何操作2020-08-23_212918.png
  • 并重新获取现在的最新值（这个重新获取的动作就是自旋）

5.8 AtomicInteger-源码解析

代码实现 :

  1. package com.itheima.threadatom4;
  3. public class AtomDemo {
  4.     public static void main(String[] args) {
  5.         MyAtomThread atom = new MyAtomThread();
  6.         for (int i = 0; i < 100; i++) {
  7.             new Thread(atom).start();
  8.         }
  9.     }
  10. }
  1. package com.itheima.threadatom4;
  3. import java.util.concurrent.atomic.AtomicInteger;
  5. public class MyAtomThread implements Runnable {
  6.     AtomicInteger ac = new AtomicInteger(0);
  8.     @Override
  9.     public void run() {
  10.         for (int i = 0; i < 100; i++) {
  11.             //1,从共享数据中读取数据到本线程栈中.
  12.             //2,修改本线程栈中变量副本的值
  13.             //3,会把本线程栈中变量副本的值赋值给共享数据.
  14.             int count = ac.incrementAndGet();
  15.             System.out.println("已经送了" + count + "个冰淇淋");
  16.         }
  17.     }
  18. }

源码解析 :

  1. //先自增，然后获取自增后的结果
  2. public final int incrementAndGet() {
  3.         //+ 1 自增后的结果
  4.         //this 就表示当前的atomicInteger（值）
  5.         //1 自增一次
  6.         return U.getAndAddInt(this, VALUE, 1) + 1;
  7. }
  9. public final int getAndAddInt(Object o, long offset, int delta) {
  10.         //v 旧值
  11.         int v;
  12.         //自旋的过程
  13.         do {
  14.             //不断的获取旧值
  15.             v = getIntVolatile(o, offset);
  16.             //如果这个方法的返回值为false，那么继续自旋
  17.             //如果这个方法的返回值为true，那么自旋结束
  18.             //o 表示的就是内存值
  19.             //v 旧值
  20.             //v + delta 修改后的值
  21.         } while (!weakCompareAndSetInt(o, offset, v, v + delta));
  22.             //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
  23.             // 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
  24.             //如果修改失败，那么继续自旋。
  25.         return v;
  26. }
  1. v= this.getIntVolatile(obj, offset);
  2.     通过对象和偏移量获取变量的值
  3.     由于volatile的修饰, 所有线程看到的v都是一样的
  5. weakCompareAndSetInt()方法
  6.     尝试修改v的值,具体地, 该方法也会通过obj和offset获取变量的值
  7.     如果这个值和v不一样, 说明其他线程修改了obj+offset地址处的值, weakCompareAndSetInt()返回false, 继续循环
  8.     如果这个值和v一样, 说明没有其他线程修改obj+offset地址处的值, 此时可以将obj+offset地址处的值改为v+delta, weakCompareAndSetInt()返回true, 退出循环
  9.     weakCompareAndSetInt()方法是原子操作, 所以compareAndSwapInt()修改obj+offset地址处的值的时候不会被其他线程中断

5.9 悲观锁和乐观锁

synchronized和CAS的区别 :

相同点：

  • 在多线程情况下，都可以保证共享数据的安全性。

不同点：

  • Synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每 次操作共享数据之前，都会上锁。（悲观锁）
  • CAS是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。
    • 如果别人修改过，那么我再次获取现在最新的值。
    • 如果别人没有修改过，那么我现在直接修改共享数据的值。（乐观锁）

6. 并发工具类

6.1 并发工具类-Hashtable

Hashtable出现的原因 :

  • 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。
  • 为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。
    • Hashtable采取悲观锁synchronized的形式保证数据的安全性
    • 只要有线程访问， 会将整张表全部锁起来， 所以Hashtable的效率低下。

代码实现 :

  1. package com.itheima.mymap;
  3. import java.util.HashMap;
  4. import java.util.Hashtable;
  6. public class MyHashtableDemo {
  7.     public static void main(String[] args) throws InterruptedException {
  8.         Hashtable<String, String> hm = new Hashtable<>();
  10.         Thread t1 = new Thread(() -> {
  11.             for (int i = 0; i < 25; i++) {
  12.                 hm.put(i + "", i + "");
  13.             }
  14.         });
  17.         Thread t2 = new Thread(() -> {
  18.             for (int i = 25; i < 51; i++) {
  19.                 hm.put(i + "", i + "");
  20.             }
  21.         });
  23.         t1.start();
  24.         t2.start();
  26.         System.out.println("----------------------------");
  27.         //为了t1和t2能把数据全部添加完毕
  28.         Thread.sleep(1000);
  30.         for (int i = 0; i < 51; i++) {
  31.             System.out.println(hm.get(i + ""));
  32.         }
  33.     }
  34. }

6.2 并发工具类-ConcurrentHashMap基本使用

ConcurrentHashMap出现的原因 :

  • 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。
  • 基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。

体系结构 :

1591168965857.png

总结 :

  1. 1 ，HashMap是线程不安全的。多线程环境下会有数据安全问题
  3. 2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下
  5. 3，ConcurrentHashMap也是线程安全的，效率较高。     在JDK7和JDK8中，底层原理不一样。

代码实现 :

  1. package com.itheima.mymap;
  3. import java.util.Hashtable;
  4. import java.util.concurrent.ConcurrentHashMap;
  6. public class MyConcurrentHashMapDemo {
  7.     public static void main(String[] args) throws InterruptedException {
  8.         ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>(100);
  10.         Thread t1 = new Thread(() -> {
  11.             for (int i = 0; i < 25; i++) {
  12.                 hm.put(i + "", i + "");
  13.             }
  14.         });
  17.         Thread t2 = new Thread(() -> {
  18.             for (int i = 25; i < 51; i++) {
  19.                 hm.put(i + "", i + "");
  20.             }
  21.         });
  23.         t1.start();
  24.         t2.start();
  26.         System.out.println("----------------------------");
  27.         //为了t1和t2能把数据全部添加完毕
  28.         Thread.sleep(1000);
  30.         //0-0 1-1 ..... 50- 50
  32.         for (int i = 0; i < 51; i++) {
  33.             System.out.println(hm.get(i + ""));
  34.         }//0 1 2 3 .... 50
  35.     }
  36. }

6.3 并发工具类-ConcurrentHashMap1.7原理

1591169254280.png

6.4 并发工具类-ConcurrentHashMap1.8原理

1591169338256.png

总结 :

  1. 1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。在第一次添加元素的时候创建哈希表
  3. 2，计算当前元素应存入的索引。
  5. 3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。
  7. 4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。
  9. 5，当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性

并发容器总结

20170206101943154.png

  • JUC包中List接口的实现类：CopyOnWriteArrayList
    • CopyOnWriteArrayList是线程安全的ArrayList
  • JUC包中Set接口的实现类：CopyOnWriteArraySet、ConcurrentSkipListSet
    • CopyOnWriteArraySet是线程安全的Set，它内部包含了一个CopyOnWriteArrayList，因此本质上是由CopyOnWriteArrayList实现的。
    • ConcurrentSkipListSet相当于线程安全的TreeSet。它是有序的Set。由ConcurrentSkipListMap实现

20170206102044874.png

  • ConcurrentHashMap：线程安全的HashMap。采用分段锁实现高效并发。
  • ConcurrentSkipListMap：线程安全的有序Map。使用跳表实现高效并发。

20170206102114249.png

  • ConcurrentLinkedQueue：线程安全的无界队列。底层采用单链表。支持FIFO。
  • ConcurrentLinkedDeque：线程安全的无界双端队列。底层采用双向链表。支持FIFO和FILO。
  • ArrayBlockingQueue：数组实现的阻塞队列。
  • LinkedBlockingQueue：链表实现的阻塞队列。
  • LinkedBlockingDeque：双向链表实现的双端阻塞队列。

6.5 并发工具类-CountDownLatch

CountDownLatch类 :

方法 解释
public CountDownLatch(int count) 参数传递线程数，表示等待线程数量
public void await() 让线程等待
public void countDown() 当前线程执行完毕

使用场景： 让某一条线程等待其他线程执行完毕之后再执行

代码实现 :

  1. package com.itheima.mycountdownlatch;
  3. import java.util.concurrent.CountDownLatch;
  5. public class ChileThread1 extends Thread {
  7.     private CountDownLatch countDownLatch;
  8.     public ChileThread1(CountDownLatch countDownLatch) {
  9.         this.countDownLatch = countDownLatch;
  10.     }
  12.     @Override
  13.     public void run() {
  14.         //1.吃饺子
  15.         for (int i = 1; i <= 10; i++) {
  16.             System.out.println(getName() + "在吃第" + i + "个饺子");
  17.         }
  18.         //2.吃完说一声
  19.         //每一次countDown方法的时候，就让计数器-1
  20.         countDownLatch.countDown();
  21.     }
  22. }
  1. package com.itheima.mycountdownlatch;
  3. import java.util.concurrent.CountDownLatch;
  5. public class ChileThread2 extends Thread {
  7.     private CountDownLatch countDownLatch;
  8.     public ChileThread2(CountDownLatch countDownLatch) {
  9.         this.countDownLatch = countDownLatch;
  10.     }
  11.     @Override
  12.     public void run() {
  13.         //1.吃饺子
  14.         for (int i = 1; i <= 15; i++) {
  15.             System.out.println(getName() + "在吃第" + i + "个饺子");
  16.         }
  17.         //2.吃完说一声
  18.         //每一次countDown方法的时候，就让计数器-1
  19.         countDownLatch.countDown();
  20.     }
  21. }
  1. package com.itheima.mycountdownlatch;
  3. import java.util.concurrent.CountDownLatch;
  5. public class ChileThread3 extends Thread {
  7.     private CountDownLatch countDownLatch;
  8.     public ChileThread3(CountDownLatch countDownLatch) {
  9.         this.countDownLatch = countDownLatch;
  10.     }
  11.     @Override
  12.     public void run() {
  13.         //1.吃饺子
  14.         for (int i = 1; i <= 20; i++) {
  15.             System.out.println(getName() + "在吃第" + i + "个饺子");
  16.         }
  17.         //2.吃完说一声
  18.         //每一次countDown方法的时候，就让计数器-1
  19.         countDownLatch.countDown();
  20.     }
  21. }
  1. package com.itheima.mycountdownlatch;
  3. import java.util.concurrent.CountDownLatch;
  5. public class MotherThread extends Thread {
  6.     private CountDownLatch countDownLatch;
  7.     public MotherThread(CountDownLatch countDownLatch) {
  8.         this.countDownLatch = countDownLatch;
  9.     }
  11.     @Override
  12.     public void run() {
  13.         //1.等待
  14.         try {
  15.             //当计数器变成0的时候，会自动唤醒这里等待的线程。
  16.             countDownLatch.await();
  17.         } catch (InterruptedException e) {
  18.             e.printStackTrace();
  19.         }
  20.         //2.收拾碗筷
  21.         System.out.println("妈妈在收拾碗筷");
  22.     }
  23. }
  1. package com.itheima.mycountdownlatch;
  3. import java.util.concurrent.CountDownLatch;
  5. public class MyCountDownLatchDemo {
  6.     public static void main(String[] args) {
  7.         //1.创建CountDownLatch的对象，需要传递给四个线程。
  8.         //在底层就定义了一个计数器，此时计数器的值就是3
  9.         CountDownLatch countDownLatch = new CountDownLatch(3);
  10.         //2.创建四个线程对象并开启他们。
  11.         MotherThread motherThread = new MotherThread(countDownLatch);
  12.         motherThread.start();
  14.         ChileThread1 t1 = new ChileThread1(countDownLatch);
  15.         t1.setName("小明");
  17.         ChileThread2 t2 = new ChileThread2(countDownLatch);
  18.         t2.setName("小红");
  20.         ChileThread3 t3 = new ChileThread3(countDownLatch);
  21.         t3.setName("小刚");
  23.         t1.start();
  24.         t2.start();
  25.         t3.start();
  26.     }
  27. }

总结 :

  1. 1. CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。
  3. 2. await()：让线程等待，当计数器为0时，会唤醒等待的线程
  5. 3. countDown()： 线程执行完毕时调用，会将计数器-1。

6.6 并发工具类-Semaphore

使用场景 :

  1. 可以控制访问特定资源的线程数量。

实现步骤 :

  1. 1，需要有人管理这个通道
  3. 2，当有车进来了，发通行许可证
  5. 3，当车出去了，收回通行许可证
  7. 4，如果通行许可证发完了，那么其他车辆只能等着

代码实现 :

  1. package com.itheima.mysemaphore;
  3. import java.util.concurrent.Semaphore;
  5. public class MyRunnable implements Runnable {
  6.     //1.获得管理员对象，
  7.     private Semaphore semaphore = new Semaphore(2);
  8.     @Override
  9.     public void run() {
  10.         //2.获得通行证
  11.         try {
  12.             semaphore.acquire();
  13.             //3.开始行驶
  14.             System.out.println("获得了通行证开始行驶");
  15.             Thread.sleep(2000);
  16.             System.out.println("归还通行证");
  17.             //4.归还通行证
  18.             semaphore.release();
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  1. package com.itheima.mysemaphore;
  3. public class MySemaphoreDemo {
  4.     public static void main(String[] args) {
  5.         MyRunnable mr = new MyRunnable();
  7.         for (int i = 0; i < 100; i++) {
  8.             new Thread(mr).start();
  9.         }
  10.     }
  11. }

线程的六种状态分别为 ？

  1. 新建，就绪，阻塞，等待，计时等待，死亡

线程池能给我们带来什么好处 ?

  1. 复用，线程创建很耗资源，从线程池中拿取创建好的线程

ThreadPoolExecutor(参数1….参数7) 七个参数分别代表的含义 ？

  1. 核心线程数，最大线程数，存活时间，时间单位，队列，线程工厂对象，拒绝策略

volatile关键字的作用 ?

  1. 多线程情况下，保证变量的可见性