线程简介

并发和并行

进程和线程

• 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
• 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
• 并发性：任何进程都可以同其他进程一起并发执行

线程（thread）：是进程中的单个顺序控制流，是一个程序内部的一条执行路径。

• 单线程：一个进程如果只有一条执行路径，则称为单线程程序
• 多线程：一个进程如果有多条执行路径，则称为多线程程序

多线程的创建方式

方式一：继承 Thread 类

这种方式的优点是编码简单，缺点：线程类已经继承 Thread，无法继承其他类，不利于扩展。

Thread 类中常用的两个构造方法：

• public Thread()：创建一个新的线程对象。
• public Thread(String threadName)：创建一个名称为 threadName 的线程对象。

常用方法

继承 Thread 类创建一个新的线程的语法：

public class MyThread extends Thread {

}

实现步骤：

• 定义一个类 MyThread 继承线程类 Thread
• 在 MyThread 类中重写 run() 方法，将实现该线程功能的代码写入 run() 方法中
• 创建 MyThread 类的对象
• 启动线程：调用线程对象的 start() 方法启动线程（启动后还是执行 run 方法的）

代码示例：

public class MyThread extends Thread {
  @Override
  public void run() {
    for(int i = 0; i < 100; i++) {
      System.out.println(i);
   }
 }
}

public class MyThreadDemo {
  public static void main(String[] args) {
    MyThread my1 = new MyThread();
    MyThread my2 = new MyThread();

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

    //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
    my1.start();
    my2.start();
 }
}

问题思考

• 为什么要重写 run()方法？

因为 run() 是用来封装被线程执行的代码。

• run() 方法和 start() 方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用。

start()：启动线程；然后由 JVM 调用此线程的 run() 方法。

• 为什么不直接调用了 run 方法，而是调用 start 启动线程。

直接调用 run 方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用 start 方法才是启动一个新的线程执行。

方式二：实现 Runnable 接口

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

Thread 构造方法（构造器）

实现 Runnable 接口的语法如下：

public class Thread extends Object implements Runnable {

}

实现步骤

• 定义一个线程任务类 MyRunnable 实现 Runnable 接口，重写 run() 方法
• 在 MyRunnable 类中重写 run() 方法
• 创建 MyRunnable 类的对象
• 创建 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数，把 MyRunnable 任务对象交给 Thread 处理。
• 启动线程，调用线程对象的 start() 方法启动线程

代码示例

public class MyRunnable implements Runnable {
  @Override
  public void run() {
    for(int i=0; i<100; i++) {
      System.out.println(Thread.currentThread().getName()+":"+i);
   }
 }
}
public class MyRunnableDemo {
  public static void main(String[] args) {
    //创建MyRunnable类的对象
    MyRunnable my = new MyRunnable();
    //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    //Thread(Runnable target)
//    Thread t1 = new Thread(my);
//    Thread t2 = new Thread(my);
    //Thread(Runnable target, String name)
    Thread t1 = new Thread(my,"高铁");
    Thread t2 = new Thread(my,"飞机");

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

实现 Runnable 接口（匿名内部类形式）

可以创建 Runnable 的匿名内部类对象，交给 Thread 处理 ，调用线程对象的 start() 启动线程。

方式三：实现 Callable 接口（JDK 5.0 新增）

在 JDK 5.0，提供了 Callable 和 FutureTask 来实现解决这种问题。这种方式的优点是：可以得到线程执行的结果。

这种方式的优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。可以在线程执行完毕后去获取线程执行的结果。

缺点：编码复杂一点。

FutureTask 的 API

实现步骤

• 得到任务对象
  • 定义一个类类实现 Callable 接口，重写 call 方法，封装要做的事情。
  • 创建 Future 的实现类 FutureTask 对象， 用 FutureTask 把 Callable 对象 作为构造方法的参数， 封装成线程任务对象。
• 把线程任务对象交给 Thread 处理。
• 启动线程：调用 Thread 的 start 方法启动线程，执行任务
• 线程执行完毕后、通过调用 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);
    }
}

总结：三种方式的对比

线程的生命周期（线程状态）

出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用 start() 方法之前线程都处于出生状态；

当用户调用 start() 方法后，线程处于就绪状态（又被称为可执行状态）；

当线程得到系统资源后就进入运行状态。一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。

当处于运行状态下的线程调用 Thread 类中的 wait() 方法时，该线程便进入等待状态，进入等待状态的线程必须调用 Thread 类中的 notify() 方法才能被唤醒，而 notifyAll() 方法是将所有处于等待状态下的线程唤醒；

当线程调用 Thread 类中的 sleep() 方法时，则会进入休眠状态。

如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入 / 输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。

当线程的 run() 方法执行完毕时，线程进入死亡状态。

使线程处于就绪状态有以下几种方法：

• 调用sleep()方法
• 调用wait()方法
• 等待输入 / 输出完成

当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态：

• 线程调用notify()方法
• 线程调用notifyAll()方法
• 线程调用interrupt()方法
• 线程的休眠时间结束
• 输入 / 输出结束

操作线程的方法（Thread 的常用方法）

Thread 常用方法：

• 获取线程名称getName()
• 设置线程名称setName()
• 获取当前线程对象currentThread()。

至于 Thread 类提供的诸如：yield（线程礼让）、join（线程加入）、interrupt、不推荐的方法 stop（线程中断） 、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法后续需要用到的时候再查资料学习了解即可。

获取和设置线程名称

示例代码：

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());
 }
}

获得当前线程的对象

注意：此方法是 Thread 类的静态方法，可以直接使用 Thread 类调用。这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。

Thread 的构造方法（构造器）

线程的休眠

代码示例：

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();
    }
}

线程的优先级

• 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
• 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

3）随机性

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();
    }
}

守护线程

代码示例：

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();
    }
}

线程同步

线程同步的核心思想

加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

同步的好处和弊端

好处：解决了多线程的数据安全问题。

弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

线程安全

线程同步机制

基本上所有解决多线程资源冲突问题的方法都是采用给定时间只允许一个线程访问共享资源，这时就需要给共享资源上一道锁。

就好比一个人上洗手间时，他进入洗手间后会将门锁上，出来时再将锁打开，然后其他人才可以进入。

在 Java 中提供了同步机制，可以有效地防止资源冲突。同步机制使用synchronized关键字。

同步代码块

原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

synchronized(同步锁对象) {
    操作共享资源的代码(核心代码)
}


锁对象要求
理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可。

锁对象的规范要求
规范上：建议使用共享资源作为锁对象。
对于实例方法建议使用 this 作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

同步代码块的同步锁对象有什么要求？
对于实例方法建议使用 this 作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

同步方法

作用：把出现线程安全问题的核心方法给上锁。

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

同步方法格式：

修饰符 synchronized 返回值类型 方法名称(形参列表) {
    操作共享资源的代码
}

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

同步方法底层原理

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
• 如果方法是实例方法：同步方法默认用 this 作为的锁对象。但是代码要高度面向对象！
• 如果方法是静态方法：同步方法默认用 类名.class 作为的锁对象。

同步代码块锁的范围更小，同步方法锁的范围更大。

Lock 锁

为了更清晰的表达如何加锁和释放锁，JDK 5 以后提供了一个新的锁对象 Lock，更加灵活、方便。Lock 实现提供比使用 synchronized 方法和语句可以获得更广泛的锁定操作。

Lock 是接口不能直接实例化，这里采用它的实现类 ReentrantLock 来构建 Lock 锁对象。

ReentrantLock 构造方法

加锁解锁方法

代码演示

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() + "正在出售第" + tickets + "张票");
                }
            } 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();
    }
}

卖票案例

• 定义一个类 SellTicket 实现 Runnable 接口，里面定义一个成员变量： <font style="color:rgb(38, 38, 38);">private int tickets = 100;</font>
• 在 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();
    }
}

**卖票案例存在的问题**

• 相同的票出现了多次
• 出现了负数的票

使用同步代码块解决数据安全问题

• 是多线程环境
• 有共享数据
• 有多条语句操作共享数据

• 基本思想：让程序没有安全问题的环境

• 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。
• Java 提供了同步代码块的方式来解决 。

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

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

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();
    }
}

使用同步方法解决数据安全问题

@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();
}

}

<h2 id="E72zo">死锁</h2>
<font style="color:rgb(38, 38, 38);">线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。</font>



<font style="color:rgb(38, 38, 38);">什么情况下会产生死锁 ？</font>

+ <font style="color:rgb(38, 38, 38);">资源有限</font>
+ <font style="color:rgb(38, 38, 38);">同步嵌套</font>



代码示例：

```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();
    }
}

线程通信

所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

线程通信常见形式

通过共享一个数据的方式实现。根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

线程通信实际应用场景

生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。

要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。

线程通信的三个常见方法

Object 类的等待和唤醒方法：

注意：上述方法应该使用当前同步锁对象进行调用。

生产者消费者

**生产者和消费者模式概述**

• 一类是生产者线程用于生产数据
• 一类是消费者线程用于消费数据

**生产者和消费者案例**

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

代码实现：

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();

    }
}

**生产者和消费者案例优化**

• 将 Desk 类中的变量，采用面向对象的方式封装起来
• 生产者和消费者类中构造方法接收 Desk 类对象，之后在 run 方法中进行使用
• 创建生产者和消费者线程对象，构造方法中传入 Desk 类对象
• 开启两个线程

代码实现：

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();

    }
}

**阻塞队列基本使用**

• ArrayBlockingQueue：底层是数组，有界
• LinkedBlockingQueue：底层是链表，无界，但不是真正的无界，最大为 int 的最大值

• <font style="color:rgb(38, 38, 38);">put(anObject)</font> ： 将参数放入队列，如果放不进去会阻塞
• <font style="color:rgb(38, 38, 38);">take()</font> ：取出第一个数据，取不到会阻塞

代码示例：

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("程序结束了");
    }
}

**阻塞队列实现等待唤醒机制**

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

public class Cooker extends Thread {

    private ArrayBlockingQueue<String> bd;

    public Cooker(ArrayBlockingQueue<String> 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<String> 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<String> bd = new ArrayBlockingQueue<>(1);

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

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

线程池

线程池就是一个可以复用线程的技术。

不使用线程池的问题

如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

线程池实现的API、参数说明

如何得到线程池对象

方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象

方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程池对象

ThreadPoolExecutor 构造器的参数说明

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,                                                                    BlockingQueue<Runnable> workQueue,                                               ThreadFactory threadFactory,                                                     RejectedExecutionHandler handler)

参数一：指定线程池的线程数量（核心线程）： corePoolSize    -- 不能小于0
参数二：指定线程池可支持的最大线程数： maximumPoolSize   -- 最大数量 >= 核心线程数量
参数三：指定临时线程的最大存活时间： keepAliveTime        -- 不能小于0
参数四：指定存活时间的单位(秒、分、时、天)： unit      -- 时间单位
参数五：指定任务队列： workQueue      -- 不能为null
参数六：指定用哪个线程工厂创建线程： threadFactory    -- 不能为null
参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler     -- 不能为null

常见 面试题

临时线程什么时候创建啊？

• 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务？

• 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

线程池处理 Runnable 任务

线程池处理 Callable 任务

Executors 工具类实现线程池