day08-线程安全,死锁,状态,通讯,线程池

今日目标

  • 线程安全
  • 线程死锁
  • 线程的状态
  • 线程间通讯
  • 线程池

1 线程安全

1.1 线程安全产生的原因

  • 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了
  1. package com.itheima.ticket_demo;
  3. /*
  4.     电影院
  5.  */
  6. public class Ticket implements Runnable {
  7.     private int ticketCount = 100; // 一共有一百张票
  9.     @Override
  10.     public void run() {
  11.         while (true) {
  12.             // 如果票的数量为0 , 那么停止买票
  13.             if (ticketCount == 0) {
  14.                 break;
  15.             } else {
  16.                 // 有剩余的票 , 开始卖票
  17.                 ticketCount--;
  18.                 System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
  19.             }
  20.         }
  21.     }
  22. }
  1. package com.itheima.ticket_demo;
  3. /*
  4.     1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
  5.     2 在Ticket类中重写run()方法实现卖票，代码步骤如下
  6.         A：判断票数大于0，就卖票，并告知是哪个窗口卖的
  7.         B：票数要减1
  8.         C：卖光之后，线程停止
  9.     3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
  10.         A：创建Ticket类的对象
  11.         B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
  12.         C：启动线程
  14.  */
  15. public class TicketDemo {
  16.     public static void main(String[] args) {
  17.         // 创建任务类对象
  18.         Ticket ticket = new Ticket();
  20.         // 创建三个线程类对象
  21.         Thread t1 = new Thread(ticket);
  22.         Thread t2 = new Thread(ticket);
  23.         Thread t3 = new Thread(ticket);
  24.         // 给三个线程命名
  25.         t1.setName("窗口1");
  26.         t2.setName("窗口2");
  27.         t3.setName("窗口3");
  28.         // 开启三个线程
  29.         t1.start();
  30.         t2.start();
  31.         t3.start();
  32.     }
  33. }

注意 : 以上代码是有问题 , 接下来继续改进
  • 因为出票是有时间的 , 所有现在在每次买票之前, 休眠100毫秒 , 尝试执行代码
  1. package com.itheima.ticket_demo;
  3. /*
  4.     电影院
  5.  */
  6. public class Ticket implements Runnable {
  7.     private int ticketCount = 100; // 一共有一百张票
  9.     @Override
  10.     public void run() {
  11.         while (true) {
  12.             // 如果票的数量为0 , 那么停止买票
  13.             if (ticketCount <= 0) {
  14.                 break;
  15.             } else {
  17.                 // 模拟出票的时间
  18.                 try {
  19.                     Thread.sleep(100);
  20.                 } catch (InterruptedException e) {
  21.                     e.printStackTrace();
  22.                 }
  24.                 // 有剩余的票 , 开始卖票
  25.                 ticketCount--;
  26.                 System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
  27.             }
  28.         }
  29.     }
  30. }
  1. package com.itheima.ticket_demo;
  3. /*
  4.     1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
  5.     2 在Ticket类中重写run()方法实现卖票，代码步骤如下
  6.         A：判断票数大于0，就卖票，并告知是哪个窗口卖的
  7.         B：票数要减1
  8.         C：卖光之后，线程停止
  9.     3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
  10.         A：创建Ticket类的对象
  11.         B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
  12.         C：启动线程
  14.  */
  15. public class TicketDemo {
  16.     public static void main(String[] args) {
  17.         // 创建任务类对象
  18.         Ticket ticket = new Ticket();
  20.         // 创建三个线程类对象
  21.         Thread t1 = new Thread(ticket);
  22.         Thread t2 = new Thread(ticket);
  23.         Thread t3 = new Thread(ticket);
  24.         // 给三个线程命名
  25.         t1.setName("窗口1");
  26.         t2.setName("窗口2");
  27.         t3.setName("窗口3");
  28.         // 开启三个线程
  29.         t1.start();
  30.         t2.start();
  31.         t3.start();
  32.     }
  33. }
  • 通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题
  • 问题出现的原因 : 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了

1.2 线程的同步

  • 概述 : java允许多线程并发执行，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证该变量的唯一性和准确性

  • 分类

    • 同步代码块
    • 同步方法
    • 锁机制。Lock

1.3 同步代码块

  1. 同步代码块 : 锁住多条语句操作共享数据，可以使用同步代码块实现
  3. 第一部分 : 格式
  4.            synchronized(任意对象) {
  5.                    多条语句操作共享数据的代码
  6.            }
  8. 第二部分 : 注意
  9.            1 默认情况锁是打开的，只要有一个线程进去执行代码了，锁就会关闭
  10.            2 当线程执行完出来了，锁才会自动打开
  12. 第三部分 : 同步的好处和弊端
  13.             好处 : 解决了多线程的数据安全问题
  14.             弊端 : 当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
  1. public class Ticket implements Runnable {
  2.     private int ticketCount = 100; // 一共有一百张票
  4.     @Override
  5.     public void run() {
  6.         while (true) {
  7.             synchronized (Ticket.class) {
  8.                 // 如果票的数量为0 , 那么停止买票
  9.                 if (ticketCount <= 0) {
  10.                     break;
  11.                 } else {
  12.                     // 模拟出票的时间
  13.                     try {
  14.                         Thread.sleep(100);
  15.                     } catch (InterruptedException e) {
  16.                         e.printStackTrace();
  17.                     }
  18.                     // 有剩余的票 , 开始卖票
  19.                     ticketCount--;
  20.                     System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
  21.                 }
  22.             }
  23.         }
  24.     }
  25. }
  1. package com.itheima.synchronized_demo1;
  3. /*
  4.     1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
  5.     2 在Ticket类中重写run()方法实现卖票，代码步骤如下
  6.         A：判断票数大于0，就卖票，并告知是哪个窗口卖的
  7.         B：票数要减1
  8.         C：卖光之后，线程停止
  9.     3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
  10.         A：创建Ticket类的对象
  11.         B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
  12.         C：启动线程
  14.  */
  15. public class TicketDemo {
  16.     public static void main(String[] args) {
  17.         // 创建任务类对象
  18.         Ticket ticket = new Ticket();
  20.         // 创建三个线程类对象
  21.         Thread t1 = new Thread(ticket);
  22.         Thread t2 = new Thread(ticket);
  23.         Thread t3 = new Thread(ticket);
  24.         // 给三个线程命名
  25.         t1.setName("窗口1");
  26.         t2.setName("窗口2");
  27.         t3.setName("窗口3");
  28.         // 开启三个线程
  29.         t1.start();
  30.         t2.start();
  31.         t3.start();
  32.     }
  33. }

1.4 同步方法

  1. 同步方法：就是把synchronized关键字加到方法上
  3. 格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }
  5. 同步代码块和同步方法的区别:
  6.     1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
  7.     2 同步代码块可以指定锁对象,同步方法不能指定锁对象
  9. 注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
  10.     1 对于非static方法,同步锁就是this。
  11.     2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象
  1. package com.itheima.synchronized_demo2;
  3. /*
  4.     同步方法：就是把synchronized关键字加到方法上
  6.     格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }
  8.     同步代码块和同步方法的区别:
  9.         1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
  10.         2 同步代码块可以指定锁对象,同步方法不能指定锁对象
  12.     注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
  13.         1 对于非static方法,同步锁就是this。
  14.         2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象
  16.  */
  17. public class Ticket implements Runnable {
  18.     private int ticketCount = 100; // 一共有一百张票
  20.     @Override
  21.     public void run() {
  22.         while (true) {
  23.             if (method()) {
  24.                 break;
  25.             }
  26.         }
  27.     }
  29.     private synchronized boolean method() {
  30.         // 如果票的数量为0 , 那么停止买票
  31.         if (ticketCount <= 0) {
  32.             return true;
  33.         } else {
  34.             // 模拟出票的时间
  35.             try {
  36.                 Thread.sleep(100);
  37.             } catch (InterruptedException e) {
  38.                 e.printStackTrace();
  39.             }
  41.             // 有剩余的票 , 开始卖票
  42.             ticketCount--;
  43.             System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
  44.             return false;
  45.         }
  46.     }
  47. }
  1. package com.itheima.synchronized_demo2;
  3. /*
  4.     1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
  5.     2 在Ticket类中重写run()方法实现卖票，代码步骤如下
  6.         A：判断票数大于0，就卖票，并告知是哪个窗口卖的
  7.         B：票数要减1
  8.         C：卖光之后，线程停止
  9.     3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
  10.         A：创建Ticket类的对象
  11.         B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
  12.         C：启动线程
  14.  */
  15. public class TicketDemo {
  16.     public static void main(String[] args) {
  17.         // 创建任务类对象
  18.         Ticket ticket = new Ticket();
  20.         // 创建三个线程类对象
  21.         Thread t1 = new Thread(ticket);
  22.         Thread t2 = new Thread(ticket);
  23.         Thread t3 = new Thread(ticket);
  24.         // 给三个线程命名
  25.         t1.setName("窗口1");
  26.         t2.setName("窗口2");
  27.         t3.setName("窗口3");
  28.         // 开启三个线程
  29.         t1.start();
  30.         t2.start();
  31.         t3.start();
  32.     }
  33. }

1.5 Lock锁

  1. 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
  2. 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
  4. Lock中提供了获得锁和释放锁的方法
  5.     void lock()：获得锁
  6.     void unlock()：释放锁
  8. Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
  9.     ReentrantLock的构造方法
  10.     ReentrantLock()：创建一个ReentrantLock的实例
  12. 注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
  1. package com.itheima.synchronized_demo3;
  3. import java.util.concurrent.locks.ReentrantLock;
  5. /*
  6.     虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
  7.     为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
  9.     Lock中提供了获得锁和释放锁的方法
  10.         void lock()：获得锁
  11.         void unlock()：释放锁
  13.     Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
  14.         ReentrantLock的构造方法
  15.         ReentrantLock()：创建一个ReentrantLock的实例
  17.     注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
  19.  */
  20. public class Ticket implements Runnable {
  21.     private int ticketCount = 100; // 一共有一百张票
  22.     ReentrantLock lock = new ReentrantLock();
  24.     @Override
  25.     public void run() {
  26.         while (true) {
  27.             try {
  28.                 lock.lock();// 加锁
  29.                 // 如果票的数量为0 , 那么停止买票
  30.                 if (ticketCount <= 0) {
  31.                     break;
  32.                 } else {
  33.                     // 模拟出票的时间
  34.                     Thread.sleep(100);
  35.                     // 有剩余的票 , 开始卖票
  36.                     ticketCount--;
  37.                     System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
  38.                 }
  39.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             } finally {
  42.                 lock.unlock();// 释放锁
  43.             }
  44.         }
  45.     }
  46. }
  1. package com.itheima.synchronized_demo3;
  3. /*
  4.     1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
  5.     2 在Ticket类中重写run()方法实现卖票，代码步骤如下
  6.         A：判断票数大于0，就卖票，并告知是哪个窗口卖的
  7.         B：票数要减1
  8.         C：卖光之后，线程停止
  9.     3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
  10.         A：创建Ticket类的对象
  11.         B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
  12.         C：启动线程
  14.  */
  15. public class TicketDemo {
  16.     public static void main(String[] args) {
  17.         // 创建任务类对象
  18.         Ticket ticket = new Ticket();
  20.         // 创建三个线程类对象
  21.         Thread t1 = new Thread(ticket);
  22.         Thread t2 = new Thread(ticket);
  23.         Thread t3 = new Thread(ticket);
  24.         // 给三个线程命名
  25.         t1.setName("窗口1");
  26.         t2.setName("窗口2");
  27.         t3.setName("窗口3");
  28.         // 开启三个线程
  29.         t1.start();
  30.         t2.start();
  31.         t3.start();
  32.     }
  33. }

2 线程死锁

2.1 概述 :

  • 死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的

2.2 产生条件 :

  • 多个线程
  • 存在锁对象的循环依赖

2.3 代码实践

  1. package com.itheima.deadlock_demo;
  3. /*
  4.     死锁 :
  5.         死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。
  6.         我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的
  7.  */
  8. public class DeadLockDemo {
  9.     public static void main(String[] args) {
  10.         String 筷子A = "筷子A";
  11.         String 筷子B = "筷子B";
  13.         new Thread(new Runnable() {
  14.             @Override
  15.             public void run() {
  16.                 while (true) {
  17.                     synchronized (筷子A) {
  18.                         System.out.println("小白拿到了筷子A ,等待筷子B....");
  19.                         synchronized (筷子B) {
  20.                             System.out.println("小白拿到了筷子A和筷子B , 开吃!!!!!");
  21.                         }
  22.                     }
  23.                     try {
  24.                         Thread.sleep(100);
  25.                     } catch (InterruptedException e) {
  26.                         e.printStackTrace();
  27.                     }
  28.                 }
  29.             }
  30.         }, "小白").start();
  33.         new Thread(new Runnable() {
  34.             @Override
  35.             public void run() {
  36.                 while (true) {
  37.                     synchronized (筷子B) {
  38.                         System.out.println("小黑拿到了筷子B ,等待筷子A....");
  39.                         synchronized (筷子A) {
  40.                             System.out.println("小黑拿到了筷子B和筷子A , 开吃!!!!!");
  41.                         }
  42.                     }
  43.                     try {
  44.                         Thread.sleep(100);
  45.                     } catch (InterruptedException e) {
  46.                         e.printStackTrace();
  47.                     }
  48.                 }
  49.             }
  50.         }, "小黑").start();
  51.     }
  52. }

3 线程的状态

4 线程通信

  • 线程间的通讯技术就是通过等待和唤醒机制，来实现多个线程协同操作完成某一项任务，例如经典的生产者和消费者案例。等待唤醒机制其实就是让线程进入等待状态或者让线程从等待状态中唤醒，需要用到两种方法，如下：

  • 等待方法 :

    • void wait() 让线程进入无限等待。
    • void wait(long timeout) 让线程进入计时等待
    • 以上两个方法调用会导致当前线程释放掉锁资源。

  • 唤醒方法 :

    • void notify() 唤醒在此对象监视器（锁对象）上等待的单个线程。
    • void notifyAll() 唤醒在此对象监视器上等待的所有线程。
    • 以上两个方法调用不会导致当前线程释放掉锁资源

  • 注意

    • 等待和唤醒的方法，都要使用锁对象调用（需要在同步代码块中调用)
    • 等待和唤醒方法应该使用相同的锁对象调用
  • ```java package com.itheima.waitnotify_demo;

/ 1 线程进入无限等待 注意：进入无限等待需要使用锁在同步代码中调用wait方法 / public class Test1 { public static void main(String[] args) { Object obj = new Object(); // 作为锁对象

  1.     new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  4.             synchronized (obj) {
  5.                 System.out.println("线程开始执行");
  6.                 System.out.println("线程进入无线等待....");
  7.                 try {
  8.                     obj.wait(); // 进入无线等待状态 , 并释放锁
  9.                 } catch (InterruptedException e) {
  10.                     e.printStackTrace();
  11.                 }
  12.                 System.out.println("无线等待被唤醒....");
  13.             }
  14.         }
  15.     }).start();
  16. }

}

  3. - 
  4. ```java
  5. package com.itheima.waitnotify_demo;
  7. /*
  8.     线程进入无限等待后被唤醒
  9.     注意：等待和唤醒是两个或多个线程之间实现的。进入无限等待的线程是不会自动唤醒，只能通过其他线程来唤醒。
  10.  */
  11. public class Test2 {
  12.     public static void main(String[] args) {
  13.         Object obj = new Object(); // 作为锁对象
  15.         new Thread(new Runnable() {
  16.             @Override
  17.             public void run() {
  18.                 synchronized (obj) {
  19.                     System.out.println("线程开始执行");
  20.                     System.out.println("线程进入无线等待....");
  21.                     try {
  22.                         obj.wait(); // 进入无线等待状态 , 并释放锁
  23.                     } catch (InterruptedException e) {
  24.                         e.printStackTrace();
  25.                     }
  26.                     System.out.println("无线等待被唤醒....");
  27.                 }
  28.             }
  29.         }).start();
  32.         new Thread(new Runnable() {
  33.             @Override
  34.             public void run() {
  35.                 try {
  36.                     Thread.sleep(3000);
  37.                 } catch (InterruptedException e) {
  38.                     e.printStackTrace();
  39.                 }
  40.                 synchronized (obj) {
  41.                     obj.notify();// 随机唤醒此监视器中等待的线程 , 不会释放锁
  42.                     System.out.println("唤醒后 , 5秒钟后释放锁");
  43.                     try {
  44.                         Thread.sleep(5000);
  45.                     } catch (InterruptedException e) {
  46.                         e.printStackTrace();
  47.                     }
  48.                 }// 释放锁
  49.             }
  50.         }).start();
  51.     }
  52. }
  • ```java package com.itheima.waitnotify_demo;

/ 3 线程进入计时等待并唤醒 注意：进入计时等待的线程，时间结束前可以被其他线程唤醒。时间结束后会自动唤醒 / public class Test3 { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { synchronized (Test3.class) { System.out.println(“获取到锁 , 开始执行”); try { System.out.println(“进入计时等待…3秒”); Test3.class.wait(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(“自动唤醒.”); } } }).start(); } }

  3. - 
  4. <a name="73c77f10"></a>
  5. ##### 生产者和消费者案例
  7. ```java
  8. package com.itheima.waitnotify_demo2;
  10. import sun.security.krb5.internal.crypto.Des;
  12. /*
  13.     生产者步骤：
  14.         1，判断桌子上是否有汉堡包
  15.             如果有就等待，如果没有才生产。
  16.         2，把汉堡包放在桌子上。
  17.         3，叫醒等待的消费者开吃
  18.  */
  19. public class Cooker implements Runnable {
  20.     @Override
  21.     public void run() {
  22.         while (true) {
  23.             synchronized (Desk.lock) {
  24.                 if (Desk.count == 0) {
  25.                     break;
  26.                 } else {
  27.                     if (Desk.flag) {
  28.                         // 桌子上有食物
  29.                         try {
  30.                             Desk.lock.wait();
  31.                         } catch (InterruptedException e) {
  32.                             e.printStackTrace();
  33.                         }
  34.                     } else {
  35.                         // 桌子上没有食物
  36.                         System.out.println("厨师生产了一个汉堡包...");
  37.                         Desk.flag = true;
  38.                         Desk.lock.notify();
  39.                     }
  40.                 }
  41.             }
  42.         }
  43.     }
  44. }
  1. package com.itheima.waitnotify_demo2;
  3. import sun.security.krb5.internal.crypto.Des;
  5. /*
  6.     消费者步骤：
  7.         1，判断桌子上是否有汉堡包。
  8.         2，如果没有就等待。
  9.         3，如果有就开吃
  10.         4，吃完之后，桌子上的汉堡包就没有了
  11.             叫醒等待的生产者继续生产
  12.             汉堡包的总数量减一
  13.  */
  14. public class Foodie implements Runnable {
  15.     @Override
  16.     public void run() {
  17.         while (true) {
  18.             synchronized (Desk.lock) {
  19.                 if (Desk.count == 0) {
  20.                     break;
  21.                 } else {
  22.                     if (Desk.flag) {
  23.                         // 桌子上有食物
  24.                         System.out.println("吃货吃了一个汉堡包...");
  25.                         Desk.count--; // 汉堡包的数量减少一个
  26.                         Desk.flag = false;// 桌子上的食物被吃掉 , 值为false
  27.                         Desk.lock.notify();
  28.                     } else {
  29.                         // 桌子上没有食物
  30.                         try {
  31.                             Desk.lock.wait();
  32.                         } catch (InterruptedException e) {
  33.                             e.printStackTrace();
  34.                         }
  35.                     }
  36.                 }
  37.             }
  38.         }
  39.     }
  40. }
  1. package com.itheima.waitnotify_demo2;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         new Thread(new Foodie()).start();
  6.         new Thread(new Cooker()).start();
  7.     }
  8. }

5 线程池

5.1 线程使用存在的问题

  • 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
    如果大量线程在执行，会涉及到线程间上下文的切换，会极大的消耗CPU运算资源

5.2 线程池的介绍

  • 其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

5.3 线程池使用的大致流程

  • 创建线程池指定线程开启的数量
  • 提交任务给线程池，线程池中的线程就会获取任务，进行处理任务。
  • 线程处理完任务，不会销毁，而是返回到线程池中，等待下一个任务执行。
  • 如果线程池中的所有线程都被占用，提交的任务，只能等待线程池中的线程处理完当前任

5.4 线程池的好处

  • 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
  • 提高响应速度。当任务到达时，任务可以不需要等待线程创建 , 就能立即执行。
  • 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存 (每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

5.4 Java提供好的线程池

  • java.util.concurrent.ExecutorService 是线程池接口类型。使用时我们不需自己实现，JDK已经帮我们实现好了

  • 获取线程池我们使用工具类java.util.concurrent.Executors的静态方

    • public static ExecutorService newFixedThreadPool (int num) : 指定线程池最大线程池数量获取线程池

  • 线程池ExecutorService的相关方法

    • Future submit(Callable task)
    • Future<?> submit(Runnable task)

  • 关闭线程池方法（一般不使用关闭方法，除非后期不用或者很长时间都不用，就可以关闭）

    • void shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务

5.5 线程池处理Runnable任务

  1. package com.itheima.threadpool_demo;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  6. /*
  7.     1 需求 :
  8.         使用线程池模拟游泳教练教学生游泳。
  9.         游泳馆（线程池）内有3名教练（线程）
  10.         游泳馆招收了5名学员学习游泳（任务）。
  12.     2 实现步骤：
  13.         创建线程池指定3个线程
  14.         定义学员类实现Runnable，
  15.         创建学员对象给线程池
  16.  */
  17. public class Test1 {
  18.     public static void main(String[] args) {
  19.         // 创建指定线程的线程池
  20.         ExecutorService threadPool = Executors.newFixedThreadPool(3);
  22.         // 提交任务
  23.         threadPool.submit(new Student("小花"));
  24.         threadPool.submit(new Student("小红"));
  25.         threadPool.submit(new Student("小明"));
  26.         threadPool.submit(new Student("小亮"));
  27.         threadPool.submit(new Student("小白"));
  29.         threadPool.shutdown();// 关闭线程池
  30.     }
  31. }
  33. class Student implements Runnable {
  34.     private String name;
  36.     public Student(String name) {
  37.         this.name = name;
  38.     }
  40.     @Override
  41.     public void run() {
  42.         String coach = Thread.currentThread().getName();
  43.         System.out.println(coach + "正在教" + name + "游泳...");
  45.         try {
  46.             Thread.sleep(3000);
  47.         } catch (InterruptedException e) {
  48.             e.printStackTrace();
  49.         }
  50.         System.out.println(coach + "教" + name + "游泳完毕.");
  51.     }
  52. }

5.6 线程池处理Callable任务

  1. package com.itheima.threadpool_demo;
  3. import java.util.concurrent.*;
  5. /*
  6.     需求: Callable任务处理使用步骤
  7.         1 创建线程池
  8.         2 定义Callable任务
  9.         3 创建Callable任务，提交任务给线程池
  10.         4 获取执行结果
  12.     <T> Future<T> submit(Callable<T> task) : 提交Callable任务方法    
  13.     返回值类型Future的作用就是为了获取任务执行的结果。
  14.     Future是一个接口，里面存在一个get方法用来获取值
  16.     练一练：使用线程池计算 从0~n的和，并将结果返回
  17.  */
  18. public class Test2 {
  19.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  20.         // 创建指定线程数量的线程池
  21.         ExecutorService threadPool = Executors.newFixedThreadPool(10);
  23.         Future<Integer> future = threadPool.submit(new CalculateTask(100));
  24.         Integer sum = future.get();
  25.         System.out.println(sum);
  26.     }
  27. }
  29. // 使用线程池计算 从0~n的和，并将结果返回
  30. class CalculateTask implements Callable<Integer> {
  31.     private int num;
  33.     public CalculateTask(int num) {
  34.         this.num = num;
  35.     }
  37.     @Override
  38.     public Integer call() throws Exception {
  39.         int sum = 0;// 求和变量
  40.         for (int i = 0; i <= num; i++) {
  41.             sum += i;
  42.         }
  43.         return sum;
  44.     }
  45. }