day12-多线程

YangeIT大约 21 分钟

day12-多线程

跳转到页底(每日作业)^[1]。

今日目标

多线程
- 线程常用方法 🍐
- 线程安全问题 🍐 理解
  - 安全解决方案 ✏️ 🍐
- 线程通讯
线程通信案例 🚀 了解原理
线程池
- 线程池创建参数 🍐 ❤️
- 添加任务给线程池 🍐 ❤️
- 线程池工具类 🚀
- 并行和并发 🚀
- 线程的生命周期 🚀

前置知识

能使用Runnable的方式创建任务，添加到Thread中运行
有过上厕所锁门的经历
理解多线程和单线程的区别

一、多线程常用方法 🚩

下面我们演示一下getName()、setName(String name)、currentThread()、sleep(long time)这些方法的使用效果。

点击查看演示代码

public class MyThread extends Thread{
    public MyThread(String name){
        super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了
    }
    @Override
    public void run() {
        //2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            //3.getName() 获取线程名称
            System.out.println(t.getName() + "输出：" + i);
        }
    }
}

再测试类中，创建线程对象，并启动线程

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName(String name) //设置线程名称;
        t1.start();
        System.out.println(t1.getName());  //Thread-0

        Thread t2 = new MyThread("2号线程");
        // t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); // Thread-1

        // 主线程对象的名字
        // 哪个线程执行它，它就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName()); // main

        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
        }
    }
}

执行上面代码，效果如下图所示，我们发现每一条线程都有自己了名字了。

点击查看join方法代码

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        // join方法作用：让当前调用这个方法的线程先执行完。
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}

执行效果是1号线程先执行完，再执行2号线程；2号线程执行完，再执行3号线程；3号线程执行完就结束了。

我们再尝试，把join()方法去掉，再看执行效果。此时你会发现2号线程没有执行完1号线程就执行了效果是多次运行才出现的，根据个人电脑而异，可能小伙伴半天也出现不了也是正常的

总结

重点练习cureentThread 获取当前线程
练习sleep(毫秒) 让当前执行的线程休眠，俗称睡一下

二、线程安全问题 🚩 🍐 细心理解

各位小伙伴，前面我们已经学习了如何创建线程，以及线程的常用方法。接下来，我们要学习一个在实际开发过程中，使用线程时最重要的一个问题，叫线程安全问题。

1️⃣ 2.1 线程安全问题概述

线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题

场景：

小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，
小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？

在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱

2️⃣ 2.2 线程安全问题的代码演示

先定义一个共享的账户类

public class Account {
    private String cardId; // 卡号
    private double money; // 余额。

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    // 小明 小红同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }

    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
}

在定义一个是取钱的线程类

public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 取钱(小明，小红)
        acc.drawMoney(100000);
    }
}

最后，再写一个测试类，在测试类中创建两个线程对象

public class ThreadTest {
    public static void main(String[] args) {
         // 1、创建一个账户对象，代表两个人的共享账户。
        Account acc = new Account("ICBC-110", 100000);
        // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。
        new DrawThread(acc, "小明").start(); // 小明
        new DrawThread(acc, "小红").start(); // 小红
    }
}

运行程序，执行效果如下。你会发现两个人都取了10万块钱，余额为-10完了。

3️⃣ 2.3 线程同步方案

上述案例中，账户中出现了负数出现了--线程安全问题！！！

解决方案：加锁

意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

Java提供了三种枷锁方案：

同步代码块

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
    //...访问共享数据的代码...
}

同步方法

public synchronized void 方法名(参数列表) {

Lock锁

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
	private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

1️⃣ 同步代码块

同步代码块的作用就是把访问共享数据的代码锁起来，以此保证线程安全。

快捷键：选中要加锁的代码，按住ctrl+alt+t 选择synchronized 👈

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。

// 小明 小红线程同时过来的
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    // this正好代表共享资源！
    synchronized (this) {
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }
}

此时再运行测试类，观察是否会出现不合理的情况。

锁对象如何选择

锁的特性：唯一性
建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
对于实例方法，建议使用this 作为锁对象
对于静态方法 static修饰的，建议把类的字节码(类名.class) 当做锁对象

2️⃣同步方法

提示

同步方法，就是把整个方法给锁住

一个线程调用这个方法
另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

// 同步方法
public synchronized void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    if(this.money >= money){
        System.out.println(name + "来取钱" + money + "成功！");
        this.money -= money;
        System.out.println(name + "来取钱后，余额剩余：" + this.money);
    }else {
        System.out.println(name + "来取钱：余额不足~");
    }
}

改完之后，再次运行测试类，观察是否会出现不合理的情况。

同步方法有没有锁对象？锁对象是谁？

同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
1. 对于实例方法，锁对象其实是this（也就是方法的调用者）
2. 对于静态方法，锁对象时类的字节码对象（类名.class）

同步代码块和同步方法区别

不存在哪个好与不好，只是一个锁住的范围大，一个范围小
同步方法是将方法中所有的代码锁住
同步代码块是将方法中的部分代码锁住

3️⃣ Lock锁

Lock锁

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）

	private final Lock lk = new ReentrantLock();

2.在需要上锁的地方加入下面的代码

	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

使用Lock锁改写前面DrawThread中取钱的方法，代码如下

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();

public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        try {
            lk.lock(); // 加锁
            // 1、判断余额是否足够
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }
}

运行程序结果，观察是否有线程安全问题。到此三种解决线程安全问题的办法我们就学习完了。

三、线程通信 🚩 🚀 了解

接下来，我们学习一下线程通信。

首先，什么是线程通信呢？

当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。

线程通信的常见模式：是生产者与消费者模型

生产者线程负责生成数据
消费者线程负责消费生产者生成的数据
注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。

阻塞队列实现消费者和生产者模型

3.1.1 核心 API BlockingQueue

BlockingQueue 阻塞队列，相当于仓库，用来放置商品

核心方法
- put(Object) 将参数放入到队列中，如果放不进去会阻塞（等待）。
- take() ：取出第一个数据，取不到会阻塞（等待）。
常见实现：
- ArrayBlockingQueue 底层是数组，有界
- LinkedBlockingQueue 底层是链表，无界，但不是真正的无界，最大值为 int 的最大值

3.1.2 步鄹和具体实现

1️⃣ 步鄹

创建一个 ArrayBlockingQueue 为 10 的阻塞队列
通过构造的形式，将队列对象传入到 Thread 类中（Produccer 生产者，Customer 消费者）
在生产者 Produccer 中的 run 方法中，调用 put 方法放入汉堡包
在消费者 Customer 的 run 方法中，调用 take 方法消费汉堡包

2️⃣ 代码实现

点击查看代码


public class Test {
    public static void main(String[] args) {
//        创建一个容器，阻塞队列，用来装食物  参数为容积   容器为公共变量
        ArrayBlockingQueue<String> jz= new ArrayBlockingQueue<String>(10);

        Produccer produccer = new Produccer(jz);
        Customer customer = new Customer(jz);

//        启动线程
        produccer.start();
        customer.start();



    }
}

/**
 * 生产者
 */
public class Produccer  extends  Thread{
//    如果要传值，使用构造方法
    ArrayBlockingQueue<String> jz;
//    总共生产50个
    int count =0;

    public Produccer(ArrayBlockingQueue<String> jz) {
        this.jz = jz;
    }

    @Override
    public void run() {
//       用来生产东西 往队列中塞东西  put
       while (count<=50){

//           如果队列满的  就睡觉
//           如果队列有空余，就生产
           try {
               jz.put("小炒肉"+count);
               System.out.println("生产者存入小炒肉"+count);
//               当容器存满后，put 会阻塞  等待消费者消费
               count++;
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
    }
}


/**
 * 消费者----线程B
 *
 */
public class Customer extends Thread{
    //    如果要传值，使用构造方法
    ArrayBlockingQueue<String> jz;

    public Customer(ArrayBlockingQueue<String> jz) {
        this.jz = jz;
    }

    @Override
    public void run() {
//        消费容器中的事物，take方法
     while (true){
//         System.out.println("消费者 正准备消费");
         String take = null;
         try {
            //  睡个100ms 让生产者先生产
             Thread.sleep(100);
             take = jz.take();
//        当队列中没有东西的时候， take会阻塞等待

             System.out.println("消费者 正在消费 "+take);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
    }
}

四、线程池 🚩 ❤️ 🍐

1️⃣ 4.1 线程池概述

提示

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

不使用线程池的场景：

假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，下次新的任务过来肯定也会创建新的线程，如果用户量非常大，创建的线程也讲越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。

使用线程池的场景

下次新的任务过来，先不创建新的线程，而是从线程池中获取线程，减少线程的创建

线程池就是一个线程复用技术，它可以提高线程的利用率

2️⃣ 4.2 创建线程池 🍐 ❤️

使用ThreadPoolExecutor类就可以用来创建线程池对象

在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类

下面是它的构造器，参数比较多，不要怕，干就完了^_。

1668066279649

接下来，用这7个参数的构造器来创建线程池的对象。代码如下

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

关于线程池，我们需要注意下面的两个问题

临时线程什么时候创建？

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

什么时候开始拒绝新的任务？

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

3️⃣ 4.3 线程池执行(提交)任务

线程池执行(提交)任务

线程池执行Runnable任务

创建好线程池之后，接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。下面的execute方法可以用来执行Runnable任务。

先准备一个线程任务类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 任务是干啥的？
        System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
        //为了模拟线程一直在执行，这里睡久一点
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);

//下面2个任务，会被临时线程的创建时机了
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);

执行上面的代码，结果输出如下

线程池执行Callable任务

接下来，我们学习使用线程池执行Callable任务。callable任务相对于Runnable任务来说，就是多了一个返回值。

执行Callable任务需要用到下面的submit方法

第一步：先准备一个Callable线程任务

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

第二步：再准备一个测试类，在测试类中创建线程池，并执行callable任务。

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象。
        ExecutorService pool = new ThreadPoolExecutor(
            3,
            5,
            8,
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<>(4),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        // 3、执行完Callable任务后，需要获取返回结果。
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

执行后，结果如下图所示

总结

课堂作业

Callable任务和Runnable任务有什么区别？🎤

4️⃣ 4.4 线程池工具类（Executors）🚀 了解

线程池工具类

参数太多、记不住，有没有快捷的创建线程池的方法呢？

有的。

Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了方法可以创建各种不能特点的线程池。如下图所示

代码操作：

接下来，我们演示一下创建固定线程数量的线程池。这几个方法用得不多，所以这里不做过多演示，小伙伴们了解一下就行了。

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {
        // 1、通过Executors创建一个线程池对象。
        ExecutorService pool = Executors.newFixedThreadPool(17);
        // 老师：核心线程数量到底配置多少呢？？？
        // 计算密集型的任务：核心线程数量 = CPU的核数 + 1
        // IO密集型的任务：核心线程数量 = CPU核数 * 2

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());

         pool.shutdown();//线程池销毁
    }
}

Executors创建线程池这么好用，为什么不推荐小伙伴们使用呢？

原因在这里：看下图，这是《阿里巴巴Java开发手册》提供的强制规范要求。

总结

课堂作业

Executors创建线程池这么好用，为什么不推荐小伙伴们使用呢？🎤

五、补充知识 🚩 🍐 🚀 了解

最后，我们再补充几个概念性的知识点，小伙伴们知道这些概念什么意思就可以了。

1️⃣ 5.1 并发和并行

前言

先学习第一个补充知识点，并发和并行。在讲解并发和并行的含义之前，我们先来了解一下什么是进程、线程？

正常运行的程序（软件）就是一个独立的进程
线程是属于进程，一个进程中包含多个线程
进程中的线程其实并发和并行同时存在（继续往下看）

我们可以打开系统的任务管理器看看（快捷键：Ctrl+Shfit+Esc），自己的电脑上目前有哪些进程。

知道了什么是进程和线程之后，接着我们再来学习并发和并行的含义。

并发：在同一时刻，有多个指令在单个 CPU 上交替执行。
03_并发

进程中的线程由CPU负责调度执行，但是CPU同时处理线程的数量是优先的，为了保证全部线程都能执行到，CPU采用轮询机制为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。（简单记：并发就是多条线程交替执行）

并行：在同一时刻，有多个指令在多个 CPU上，同时执行。
02_并行

多线程到底是并发还是并行呢？

其实多个线程在我们的电脑上执行，并发和并行是同时存在的。

总结

以下图片是并行还是并发？

以下图片是并行还是并发？

图片一:

图片 2

图片 3：

2️⃣ 5.2 线程的生命周期

生命周期

接下来，我们学习最后一个有关线程的知识点，叫做线程的生命周期。所谓生命周期就是线程从生到死的过程中间有哪些状态，以及这些状态之间是怎么切换的。

为了让大家同好的理解线程的生命周期，先用人的生命周期举个例子，人从生到死有下面的几个过程。在人的生命周期过程中，各种状态之间可能会有切换，线程也是一样的。

接下来就来学习线程的生命周期。在Thread类中有一个嵌套的枚举类叫Thread.Status，这里面定义了线程的6中状态。如下图所示

NEW: 新建状态，线程还没有启动
RUNNABLE: 可以运行状态，线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态，没有获取到锁处于这个状态
WAITING: 无限等待状态，线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态，线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时，处于这个状态。

这几种状态之间切换关系如下图所示

代码演示

/**
 * 1.线程有6种状态，如果不记得，直接在Thread源码中，看State枚举
 * 2.wait方法会导致线程处于Waiting状态，直到被notify或者notifyAll唤醒， wait，notify,notifyAll必须在synchronized 包裹中执行
 * 3.当线程执行完后，会处于消亡状态
 */
public class ThreadStateTest {
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {

                synchronized (Thread.class) {
                    try {
                        //思考：如果使用sleep 此时状态是什么？
                        Thread.sleep(2222);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }

                System.out.println(Thread.currentThread().getName() + " 执行了");
            }
        });
        System.out.println("1.此时thread的状态为：" + thread1.getState());
        thread1.start();
        System.out.println("2.此时thread的状态为：" + thread1.getState());
        Thread.sleep(1111);
        System.out.println("3.此时thread的状态为：" + thread1.getState());
        Thread.sleep(5555);
        System.out.println("4.此时thread的状态为：" + thread1.getState());
    }
}

运行截图：

作业

来做点作业巩固一下吧！！！✏️ 💪

建议也是要求：
1. 做题之前先审题，标注可能用到的技术
2. 做题要写注释，然后写代码
3. 先问自己，再看笔记，实在不知道再问他人

页底标记 ↩︎

day12-多线程

# day12-多线程

# 一、多线程常用方法 🚩

# 二、线程安全问题 🚩 🍐 细心理解

# 1️⃣ 2.1 线程安全问题概述

# 2️⃣ 2.2 线程安全问题的代码演示

# 3️⃣ 2.3 线程同步方案

# 1️⃣ 同步代码块

# 2️⃣同步方法

# 3️⃣ Lock锁

# 三、线程通信 🚩 🚀 了解

# 阻塞队列实现消费者和生产者模型

# 3.1.1 核心 API BlockingQueue

# 3.1.2 步鄹和具体实现

# 1️⃣ 步鄹

# 2️⃣ 代码实现

# 四、线程池 🚩 ❤️ 🍐

# 1️⃣ 4.1 线程池概述

# 2️⃣ 4.2 创建线程池 🍐 ❤️

# 3️⃣ 4.3 线程池执行(提交)任务

# 线程池执行Runnable任务

# 线程池执行Callable任务

# 4️⃣ 4.4 线程池工具类（Executors）🚀 了解

# 五、补充知识 🚩 🍐 🚀 了解

# 1️⃣ 5.1 并发和并行

# 2️⃣ 5.2 线程的生命周期

day12-多线程

一、多线程常用方法 🚩

二、线程安全问题 🚩 🍐 细心理解

1️⃣ 2.1 线程安全问题概述

2️⃣ 2.2 线程安全问题的代码演示

3️⃣ 2.3 线程同步方案

1️⃣ 同步代码块

2️⃣同步方法

3️⃣ Lock锁

三、线程通信 🚩 🚀 了解

阻塞队列实现消费者和生产者模型

3.1.1 核心 API BlockingQueue

3.1.2 步鄹和具体实现

1️⃣ 步鄹

2️⃣ 代码实现

四、线程池 🚩 ❤️ 🍐

1️⃣ 4.1 线程池概述

2️⃣ 4.2 创建线程池 🍐 ❤️

3️⃣ 4.3 线程池执行(提交)任务

线程池执行Runnable任务

线程池执行Callable任务

4️⃣ 4.4 线程池工具类（Executors）🚀 了解

五、补充知识 🚩 🍐 🚀 了解

1️⃣ 5.1 并发和并行

2️⃣ 5.2 线程的生命周期