一、相关概念

1.1 并发和并行

并行（ parallel ）：指两个或多个事件在 同一时刻 发生（同时发生）。指在同一时刻，有多条指令在多个处理器上同时执行。
并发（ concurrency ）：指两个或多个事件在 同一个时间段内 发生。指在同一个时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（ CPU ），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU ，便是多核处理器，核越多， 并行 处理的程序越多，能大大的提高电脑运行的效率。

注意：单核 处理器的计算机肯定是 不能并行 的处理多个任务的，只能是多个任务在单个 CPU 上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个 CPU 时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

单核 CPU ：只能并发。
多核 CPU ：并发+并行。

例子：
并行：多项工作一起执行，之后再汇总，例如：泡方便面，电水壶烧水，一边撕调料倒入桶中
并发：同一时刻多个线程在访问同一个资源，多个线程对一个点，例如：春运抢票、电商秒杀…

1.2 进程和线程
程序 ：为了完成某个任务和功能，选择一种编程语言编写的一组指令的集合。
软件 ：1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。

1.2.1 什么是进程
**进程** ：是内存中正在运行的软件（应用程序）
- 独立性：进程是一个能独立运行的基本单位(都有一个独立的内存空间)，同时也是系统分配资源和调度的独立单位。
- 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。
- 并发性：任何进程都可以同其他进程一起并发执行

1.2.1 什么是线程

**线程**：线程是进程中的一个执行单元，负责当前进程中程序的执行，
例如在计算机中： 04_多线程示例.png
再例如：

单线程：一个进程中至少有一个线程，如果进程只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序
简而言之：一个软件中至少有一个应用程序，应用程序的一次运行就是一个进程，一个进程中至少有一个线程。

进程是操作系统调度和分配资源的最小单位，线程是 CPU 调度的最小单位。不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。对于方法区，堆中中的同一个对象的内存，线程之间是可以共享的，但是栈的局部变量永远是独立的。

1.3 线程调度

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

05_多线程示例图.png

1.4 多线程的应用场景

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。例如：
- 1、定时向大量（100w以上）的用户发送邮件；
- 2、异步处理，例如：发微博、记录日志等；
- 3、分布式计算
  二、线程的创建和使用
  2.1 概述
Java 语言的 JVM 允许程序运行多个线程，它通过 java.lang.Thread 类来体现。
Thread 类的特性：
- 每个线程都是通过某个特定 Thread 对象的 run() 方法来完成操作的，经常把 run() 方法的主体称为 线程体 。
- 通过该 Thread 对象的 start() 方法来启动这个线程，而非直接调用 run() 。

2.2 创建线程的方式

2.2.1 概述

JDK 5 之前创建线程的两种方式：
- ① 继承Thread类。
- ② 实现Runnable接口。
  2.2.2 继承 Thread 类
方法介绍 | 方法名 | 说明 | | —- | —- | | void run() | 在线程开启后，此方法将被调用执行 | | void start() | 使此线程开始执行，Java虚拟机会调用run方法() |
实现步骤：
- ① 定义子类继承 Thread 类。
- ② 子类中重写 Thread 类中的 run 方法。
- ③ 创建 Thread 子类对象，即创建了线程对象。。
- ④ 调用线程对象 start 方法：启动线程，调用 run 方法。
代码演示： ```java

/**

继承Thread类并重写run方法的方式创建线程类 */ public class SubThread extends Thread {

@Override public void run() {

 for (int i = 0; i < 50; i++) {
     System.out.println(Thread.currentThread().getName() + "：run--" + i);
 }

} }

```java
public class Test {
 public static void main(String[] args) {
     // 创建线程对象
     SubThread subThread = new SubThread();
     // 调用start方法启动线程，JVM会调用run方法
     // start不能调用多次
     subThread.start();

     for (int i = 0; i < 50; i++) {
         System.out.println(Thread.currentThread().getName() + "：run--" + i);
     }
 }
}

两个小问题
- 为什么要重写run()方法？
  因为run()是用来封装被线程执行的代码
- run()方法和start()方法的区别？
  run()：封装线程执行的代码，直接调用，相当于普通方法的调用
  start()：启动线程；然后由JVM调用此线程的run()方法
  注意事项：
  - ① 如果自己手动调用 run() 方法，那么就只是普通方法，没有启动多线程模式。
  - ② run() 方法由 JVM 调用，什么时候调用，执行的过程控制都有操作系统的 CPU 调度决定。
  - ③ 想要启动多线程，必须调用 start 方法。
  - ④ 一个线程对象只能调用一次 start() 方法启动，如果重复调用了，则将抛出以上的异常 IllegalThreadStateException 。

2.2.3 实现 Runnable 接口

Thread构造方法 | 方法名 | 说明 | | —- | —- | | Thread(Runnable target) | 分配一个新的Thread对象 | | Thread(Runnable target, String name) | 分配一个新的Thread对象 |
实现步骤：
- ① 定义子类，实现 Runnable 接口。
- ② 子类中重写 Runnable 接口中的 run 方法。
- ③ 通过 Thread 类含参构造器创建线程对象。
- ④ 将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造器中。
- ⑤ 调用 Thread 类的 start 方法：开启线程，调用 Runnable 子类接口的 run 方法。

示例：

public class SubRunnable implements Runnable {
  @Override
  public void run() {
      for (int i = 0; i < 50; i++) {
          System.out.println(Thread.currentThread().getName() + "：run--" + i);
      }
  }
}

public class Test {
  public static void main(String[] args) {
      SubRunnable runnable = new SubRunnable();

      Thread thread = new Thread(runnable);
      thread.start();

      Thread thread2 = new Thread(runnable);
      thread2.start();
  }
}

2.2.4 实现Callable接口

方法介绍
| 方法名 | 说明 | | —- | —- | | V call() | 计算结果，如果无法计算结果，则抛出一个异常 | | FutureTask(Callable callable) | 创建一个 FutureTask，一旦运行就执行给定的 Callable | | V get() | 如有必要，等待计算完成，然后获取其结果 |
实现步骤
- 定义一个类MyCallable实现Callable接口
- 在MyCallable类中重写call()方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 再调用get方法，就可以获取线程结束之后的结果。

代码演示

public class MyCallable implements Callable<String> {
 @Override
 public String call() throws Exception {
     for (int i = 0; i < 100; i++) {
         System.out.println("跟女孩表白" + i);
     }
     //返回值就表示线程运行完毕之后的结果
     return "答应";
 }
}
public class Demo {
 public static void main(String[] args) throws ExecutionException, InterruptedException {
     //线程开启之后需要执行里面的call方法
     MyCallable mc = new MyCallable();

     //Thread t1 = new Thread(mc);

     //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
     FutureTask<String> ft = new FutureTask<>(mc);

     //创建线程对象
     Thread t1 = new Thread(ft);

     String s = ft.get();
     //开启线程
     t1.start();

     //String s = ft.get();
     System.out.println(s);
 }
}

2.2.5 继承方式和实现方式的对比

实现Runnable、Callable接口
- 好处:
  - 避免了单继承的局限，扩展性强，实现该接口的同时还可以继承其他的类
  - 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源
- 缺点: 编程相对复杂，不能直接使用Thread类中的方法
继承Thread类
- 好处: 编程比较简单，可以直接使用Thread类中的方法
- 缺点: 可以扩展性较差，不能再继承其他的类
  2.3 设置线程名称和获取线程名称
方法介绍 | 方法名 | 说明 | | —- | —- | | public final synchronized void setName(String name) | 将此线程的名称更改为等于参数name | | public final String getName() | 返回此线程的名称 | | public static Thread currentThread( ) | 返回对当前正在执行的线程对象的引用 |

代码演示

public class MyThread extends Thread {
  public MyThread() {}
  public MyThread(String name) {
      super(name);
  }

  @Override
  public void run() {
      for (int i = 0; i < 100; i++) {
          System.out.println(getName()+":"+i);
      }
  }
}
public class MyThreadDemo {
  public static void main(String[] args) {
      MyThread my1 = new MyThread();
      MyThread my2 = new MyThread();

      //void setName(String name)：将此线程的名称更改为等于参数 name
      my1.setName("高铁");
      my2.setName("飞机");

      //Thread(String name)
      MyThread my1 = new MyThread("高铁");
      MyThread my2 = new MyThread("飞机");

      my1.start();
      my2.start();

      //static Thread currentThread() 返回对当前正在执行的线程对象的引用
      System.out.println(Thread.currentThread().getName());
  }
}

2.4 线程的优先级

每个线程都有一定的优先级，优先级高的线程将获得较多的执行机会。
Thread 类提供了以下方法来设置和获取线程的优先级
优先级相关方法 | 方法名 | 说明 | | —- | —- | | final int getPriority() | 返回此线程的优先级 | | final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |

代码演示：

public class MyCallable implements Callable<String> {
  @Override
  public String call() throws Exception {
      for (int i = 0; i < 100; i++) {
          System.out.println(Thread.currentThread().getName() + "---" + i);
      }
      return "线程执行完毕了";
  }
}
public class Demo {
  public static void main(String[] args) {
      //优先级: 1 - 10 默认值:5
      MyCallable mc = new MyCallable();

      FutureTask<String> ft = new FutureTask<>(mc);

      Thread t1 = new Thread(ft);
      t1.setName("飞机");
      t1.setPriority(10);
      //System.out.println(t1.getPriority());//5
      t1.start();

      MyCallable mc2 = new MyCallable();

      FutureTask<String> ft2 = new FutureTask<>(mc2);

      Thread t2 = new Thread(ft2);
      t2.setName("坦克");
      t2.setPriority(1);
      //System.out.println(t2.getPriority());//5
      t2.start();
  }
}

注意：

线程创建时继承的是父线程的优先级。
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。

2.5 线程休眠

相关方法
| 方法名 | 说明 | | —- | —- | | static void sleep(long millis) | 使当前正在执行的线程停留（暂停执行）指定的毫秒数 |

代码演示

public class MyRunnable implements Runnable {
 @Override
 public void run() {
     for (int i = 0; i < 100; i++) {
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         System.out.println(Thread.currentThread().getName() + "---" + i);
     }
 }
}
public class Demo {
 public static void main(String[] args) throws InterruptedException {
     /*System.out.println("睡觉前");
     Thread.sleep(3000);
     System.out.println("睡醒了");*/

     MyRunnable mr = new MyRunnable();

     Thread t1 = new Thread(mr);
     Thread t2 = new Thread(mr);

     t1.start();
     t2.start();
 }
}

2.6 守护线程【应用】

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

代码演示

public class MyThread1 extends Thread {
 @Override
 public void run() {
     for (int i = 0; i < 10; i++) {
         System.out.println(getName() + "---" + i);
     }
 }
}
public class MyThread2 extends Thread {
 @Override
 public void run() {
     for (int i = 0; i < 100; i++) {
         System.out.println(getName() + "---" + i);
     }
 }
}
public class Demo {
 public static void main(String[] args) {
     MyThread1 t1 = new MyThread1();
     MyThread2 t2 = new MyThread2();

     t1.setName("女神");
     t2.setName("备胎");

     //把第二个线程设置为守护线程
     //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
     t2.setDaemon(true);

     t1.start();
     t2.start();
 }
}

2.7 线程终止（了解）

方法名	说明
void join()	等待该线程终止
void join(long millis)	等待该线程终止的时间最长为 millis 毫秒
void join(long millis, int nanos)	等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒：

public class SubThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        SubThread s1 = new SubThread();

        SubThread s2 = new SubThread();

        s1.start();
        s1.join();
        s2.start();
    }
}

2.8 线程礼让（了解）

方法名	说明
public static void yield()	线程礼让：

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。
若队列中没有同优先级的线程，忽略此方法。

三、线程同步

3.1 卖票【应用】

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

代码实现

public class SellTicket implements Runnable {
 private int tickets = 100;
 //在SellTicket类中重写run()方法实现卖票，代码步骤如下
 @Override
 public void run() {
     while (true) {
         if(ticket <= 0){
                 //卖完了
                 break;
             }else{
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 ticket--;
                 System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
             }
     }
 }
}
public class SellTicketDemo {
 public static void main(String[] args) {
     //创建SellTicket类的对象
     SellTicket st = new SellTicket();

     //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
     Thread t1 = new Thread(st,"窗口1");
     Thread t2 = new Thread(st,"窗口2");
     Thread t3 = new Thread(st,"窗口3");

     //启动线程
     t1.start();
     t2.start();
     t3.start();
 }
}

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

卖票出现了问题
- 相同的票出现了多次
- 出现了负数的票
问题产生原因
线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题

3.3 同步代码块解决数据安全问题【应用】

安全问题出现的条件
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式来解决
同步代码块格式：
```
synchronized(任意对象) { 
 多条语句操作共享数据的代码 
}
```
synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
同步的好处和弊端
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

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

@Override public void run() {

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

} }

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

    Thread t1 = new Thread(st, "窗口1");
    Thread t2 = new Thread(st, "窗口2");
    Thread t3 = new Thread(st, "窗口3");

    t1.start();
    t2.start();
    t3.start();
}

}



<a name="d1e406e5"></a>
### 3.4 同步方法解决数据安全问题【应用】

-  同步方法的格式<br />同步方法：就是把synchronized关键字加到方法上 
```java
修饰符 synchronized 返回值类型 方法名(方法参数) { 
    方法体；
}

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

静态同步方法
同步静态方法：就是把synchronized关键字加到静态方法上
```
修饰符 static synchronized 返回值类型 方法名(方法参数) { 
 方法体；
}
```
同步静态方法的锁对象是什么呢?
类名.class

代码演示

public class MyRunnable implements Runnable {
 private static int ticketCount = 100;

 @Override
 public void run() {
     while(true){
         if("窗口一".equals(Thread.currentThread().getName())){
             //同步方法
             boolean result = synchronizedMthod();
             if(result){
                 break;
             }
         }

         if("窗口二".equals(Thread.currentThread().getName())){
             //同步代码块
             synchronized (MyRunnable.class){
                 if(ticketCount == 0){
                    break;
                 }else{
                     try {
                         Thread.sleep(10);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     ticketCount--;
                     System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                 }
             }
         }

     }
 }

 private static synchronized boolean synchronizedMthod() {
     if(ticketCount == 0){
         return true;
     }else{
         try {
             Thread.sleep(10);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         ticketCount--;
         System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
         return false;
     }
 }
}

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

   t1.setName("窗口一");
   t2.setName("窗口二");

   t1.start();
   t2.start();
   }
}

3.5 Lock锁【应用】

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock构造方法
| 方法名 | 说明 | | —- | —- | | ReentrantLock() | 创建一个ReentrantLock的实例 |
加锁解锁方法
| 方法名 | 说明 | | —- | —- | | void lock() | 获得锁 | | void unlock() | 释放锁 |

代码演示 ```java public class Ticket implements Runnable { //票的数量 private int ticket = 100; private Object obj = new Object(); private ReentrantLock lock = new ReentrantLock();

@Override public void run() {

 while (true) {
     //synchronized (obj){//多个线程必须使用同一把锁.
     try {
         lock.lock();
         if (ticket <= 0) {
             //卖完了
             break;
         } else {
             Thread.sleep(100);
             ticket--;
             System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
         }
     } catch (InterruptedException e) {
         e.printStackTrace();
     } finally {
         lock.unlock();
     }
     // }
 }

} }

public class Demo { public static void main(String[] args) { Ticket ticket = new Ticket();

    Thread t1 = new Thread(ticket);
    Thread t2 = new Thread(ticket);
    Thread t3 = new Thread(ticket);

    t1.setName("窗口一");
    t2.setName("窗口二");
    t3.setName("窗口三");

    t1.start();
    t2.start();
    t3.start();
}

}



<a name="911885d4"></a>
### 3.6 死锁【理解】

-  概述<br />线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行 
-  什么情况下会产生死锁 
   1. 资源有限
   1. 同步嵌套
-  代码演示 
```java
public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

3.7 synchronized 与 Lock 的对比

① Lock 是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized 是隐式锁，出了作用域自动释放。
② Lock 只有代码块锁，synchronized 有代码块锁和方法锁。
③ 使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）。

四、线程通信

4.1 为什么需要线程通信？

多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。而多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些通信机制，可以协调它们的工作，以此来帮我们达到多线程共同操作一份数据。
比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— 等待唤醒机制 。

4.2 等待唤醒机制

等待唤醒机制是多个线程的一种 协作 机制。谈到线程我们经常想到的是线程间的 竞争（race） ，比如去争夺锁，但是线程间也会有协作机制。
等待唤醒机制就是在一个线程满足某个条件时，就进入等待状态（ wait()/wait(time) ），等待其他线程执行完他们的指定代码过后再将其唤醒（ notify() ）或可以指定 wait 的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll() 来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
- wait() ：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll() 方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify() ：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
- notifyAll () ：唤醒正在排队等待资源的所有线程结束等待。
  注意：
  - 被通知线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
  - 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行）状态；否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁）状态
调用 wait 和 notify 方法需要注意的细节：
- ① wait 方法与 notify 方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过 notify 唤醒使用同一个锁对象调用的 wait 方法后的线程。
- ② wait 方法与 notify 方法是属于 Object 类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object 类的。
- ③ wait 方法与 notify 方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这 2 个方法。

4.3 生产者消费者

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

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

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

案例需求
- 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
- 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
  1.判断是否有包子,决定当前线程是否执行
  2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
  3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子
- 消费者类(Foodie)：实现Runnable接口，重写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. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
    while(true){
        synchronized (Desk.lock){
            if(Desk.count == 0){
                break;
            }else{
                if(Desk.flag){
                    //有
                    System.out.println("吃货在吃汉堡包");
                    Desk.flag = false;
                    Desk.lock.notifyAll();
                    Desk.count--;
                }else{
                    //没有就等待
                    //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                    try {
                        Desk.lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

}

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

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

    Foodie f = new Foodie();
    Cooker c = new Cooker();

    f.start();
    c.start();

}

}



<a name="02aa8418"></a>
### 4.3生产者和消费者案例优化【应用】

-  需求 
   - 将Desk类中的变量,采用面向对象的方式封装起来
   - 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用
   - 创建生产者和消费者线程对象,构造方法中传入Desk类对象
   - 开启两个线程
-  代码实现 
```java
public class Desk {

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

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
   // private int count = 10;
    private int count;

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

    public Desk() {
        this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}

public class Cooker extends Thread {

    private Desk desk;

    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(!desk.isFlag()){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Foodie extends Thread {
    private Desk desk;

    public Foodie(Desk desk) {
        this.desk = desk;
    }

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

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(desk.isFlag()){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

    }
}

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

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

        Desk desk = new Desk();

        Foodie f = new Foodie(desk);
        Cooker c = new Cooker(desk);

        f.start();
        c.start();

    }
}

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

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

代码示例

public class Demo02 {
 public static void main(String[] args) throws Exception {
     // 创建阻塞队列的对象,容量为 1
     ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);

     // 存储元素
     arrayBlockingQueue.put("汉堡包");

     // 取元素
     System.out.println(arrayBlockingQueue.take());
     System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞

     System.out.println("程序结束了");
 }
}

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

案例需求
- 生产者类(Cooker)：实现Runnable接口，重写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) {
```
 this.bd = bd;
```
} // 生产者步骤： // 1，判断桌子上是否有汉堡包 // 如果有就等待，如果没有才生产。 // 2，把汉堡包放在桌子上。 // 3，叫醒等待的消费者开吃。

@Override public void run() {
```
 while (true) {
     try {
         bd.put("汉堡包");
         System.out.println("厨师放入一个汉堡包");
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }
```
} }

public class Foodie extends Thread { private ArrayBlockingQueue bd;

public Foodie(ArrayBlockingQueue<String> bd) {
    this.bd = bd;
}

@Override
public void run() {

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

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

}

}

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

    Foodie f = new Foodie(bd);
    Cooker c = new Cooker(bd);

    f.start();
    c.start();
}

} ```

Java 讲义

多线程

一、相关概念

1.1 并发和并行

1.2 进程和线程

1.2.1 什么是进程

1.2.1 什么是线程

1.3 线程调度

1.4 多线程的应用场景

二、线程的创建和使用

2.1 概述

2.2 创建线程的方式

2.2.1 概述

2.2.2 继承 Thread 类

2.2.3 实现 Runnable 接口

2.2.4 实现Callable接口

2.2.5 继承方式和实现方式的对比

2.3 设置线程名称和获取线程名称

2.4 线程的优先级

2.5 线程休眠

2.6 守护线程【应用】

2.7 线程终止（了解）

2.8 线程礼让（了解）

三、线程同步

3.1 卖票【应用】

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

3.3 同步代码块解决数据安全问题【应用】

3.5 Lock锁【应用】

3.7 synchronized 与 Lock 的对比

四、线程通信

4.1 为什么需要线程通信？

4.2 等待唤醒机制

4.3 生产者消费者

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

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

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

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

五、单例设计模式

六、线程池

七、线程的生命周期