当前位置：首页 > news >正文

javaSE学习笔记22-线程（thread）-线程通信、线程池

news 来源：原创 2025/9/19 22:31:29

线程通信

应用场景：生产者和消费者问题
    假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
    如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
    如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

线程通信-分析
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
    对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
    对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
    在生产者消费者问题中，仅有synchronized是不够的
        synchronized可阻止并发更新同一个共享资源，实现了同步
        synchronized不能用来实现不同线程之间的消息传递（通信）
    java提供了几个方法解决线程之间的通信问题（均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException）
    方法名                作用
    wait()               表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
    wait(long timeout)   指定等待的毫秒数
    notify()             唤醒一个处于等待状态的线程
    notifyAll()         唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

解决方式1
    并发协作模型”生产者/消费者模式“ -->管程法
        生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
        消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
        缓冲区：消费者不能直接使用生产者的数据，他们之间有个”缓冲区“
        生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

解决方式2
并发协作模型”生产者/消费者模式“ -->信号灯法

方式1代码

package com.kuang.thread;/*
线程通信
应用场景：生产者和消费者问题假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止线程通信-分析
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费在生产者消费者问题中，仅有synchronized是不够的synchronized可阻止并发更新同一个共享资源，实现了同步synchronized不能用来实现不同线程之间的消息传递（通信）java提供了几个方法解决线程之间的通信问题（均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException）方法名                作用wait()               表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁wait(long timeout)   指定等待的毫秒数notify()             唤醒一个处于等待状态的线程notifyAll()          唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度解决方式1并发协作模型”生产者/消费者模式“ -->管程法生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；缓冲区：消费者不能直接使用生产者的数据，他们之间有个”缓冲区“生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据解决方式2并发协作模型”生产者/消费者模式“ -->信号灯法*///测试：生产者消费者模型--》利用缓冲区解决：管程法//生产者，消费者，产品，缓冲区
public class TestPC {public static void main(String[] args) {Synchronizer container = new Synchronizer();//创建缓冲区//创建生产者线程Producers producer = new Producers(container);//创建消费者线程Consumer consumer = new Consumer(container);//启动生产者和消费者线程producer.start();consumer.start();}
}//生产者
class Producers extends Thread{Synchronizer container;//定义一个容器public Producers(Synchronizer container){this.container = container;}@Overridepublic void run() {for (int i = 1; i < 20; i++) {System.out.println("生产了第 " + i + " 个产品");container.push(new Product(i));//将产品放入缓冲区try{Thread.sleep(1000);//模拟生产耗时} catch (InterruptedException e){e.printStackTrace();}}}
}//消费者
class Consumer extends Thread{Synchronizer container;//定义一个容器public Consumer(Synchronizer container){this.container = container;}@Overridepublic void run() {for (int i = 1; i < 20; i++) {Product product = container.pop();//从缓冲区(仓库)取出产品System.out.println("消费了第 " + product.id + " 个产品");try{Thread.sleep(3000);//模拟消费耗时} catch (InterruptedException e){e.printStackTrace();}}}
}//产品
class Product {int id;//产品编号public Product(int id){this.id = id;}
}//缓冲区（商店/仓库）
class Synchronizer {//需要一个容器大小Product[] products = new Product[10];//容器计数器int count = 0;//生产者放入产品public synchronized void push(Product product) {//如果容器满了，就需要等待消费者消费,生产者等待if(count == products.length) {System.out.println("缓冲区(仓库)已满，生产者等待...");try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//如果没有满，我们就需要丢入产品(放入产品)products[count] = product;count++;System.out.println("生产者生产放入第 " + product.id + " 个产品，当前缓冲区里有了：" + count +"个产品");this.notifyAll();//通知消费者可以消费了}//消费者消费产品public synchronized Product pop(){//如果容器为空，消费者等待while(count == 0){try {System.out.println("缓冲区为空，消费者等待...");wait();//消费者等待}catch (InterruptedException e){e.printStackTrace();}}//如果容器不为空，取出产品count--;Product product = products[count];System.out.println("消费者消费取出了第 " + product.id + " 个产品，当前缓冲区里还剩：" + count + "个产品");//如果缓冲区（仓库）为空，没有商品了，立即通知生产者生产商品if (count == 0) {System.out.println("缓冲区为空，仓库没有商品了，通知生产者生产商品...");this.notifyAll();//通知生产者可以生产了}return  product;}
}

这段代码实现了一个经典的生产者-消费者模型，通过线程间的通信和同步机制（wait() 和 notify()）来协调生产者和消费者的行为。以下是代码的详细分析和实现逻辑：

代码结构

TestPC 类：
- 主类，包含 main 方法，用于启动生产者和消费者线程。
- 创建了一个缓冲区（Synchronizer 对象），并启动生产者和消费者线程。
Producers 类：
- 生产者线程，负责生产产品并将其放入缓冲区。
- 通过 container.push() 方法将产品放入缓冲区。
Consumer 类：
- 消费者线程，负责从缓冲区取出产品并消费。
- 通过 container.pop() 方法从缓冲区取出产品。
Product 类：
- 表示产品的类，包含一个 id 属性，用于标识产品的编号。
Synchronizer 类：
- 缓冲区类，用于存储产品。
- 提供了 push() 和 pop() 方法，分别用于生产者和消费者操作缓冲区。
- 使用 wait() 和 notify() 实现线程间的通信和同步。

代码逻辑

1. 生产者逻辑

生产者线程通过 run() 方法不断生产产品。
每次生产一个产品后，调用 container.push() 方法将产品放入缓冲区。
如果缓冲区已满，生产者会调用 wait() 进入等待状态，直到消费者消费产品后唤醒它。
生产者生产完产品后，会调用 notifyAll() 通知消费者可以消费了。

2. 消费者逻辑

消费者线程通过 run() 方法不断从缓冲区取出产品并消费。
每次消费一个产品时，调用 container.pop() 方法从缓冲区取出产品。
如果缓冲区为空，消费者会调用 wait() 进入等待状态，直到生产者生产产品后唤醒它。
消费者消费完产品后，如果发现缓冲区为空，会调用 notifyAll() 通知生产者可以生产了。

3. 缓冲区逻辑

缓冲区是一个固定大小的数组（products），用于存储产品。
count 表示当前缓冲区中的产品数量。
push() 方法用于生产者将产品放入缓冲区。如果缓冲区已满，生产者会等待。
pop() 方法用于消费者从缓冲区取出产品。如果缓冲区为空，消费者会等待。
使用 wait() 和notifyAll() 实现线程间的通信和同步。

代码执行流程

生产者生产产品：
- 生产者生产产品并调用 push() 方法将产品放入缓冲区。
- 如果缓冲区已满，生产者会进入等待状态。
消费者消费产品：
- 消费者调用 pop() 方法从缓冲区取出产品。
- 如果缓冲区为空，消费者会进入等待状态。
线程通信：
- 当生产者放入产品后，会调用 notifyAll() 唤醒等待的消费者。
- 当消费者取出产品后，如果发现缓冲区为空，会调用 notifyAll() 唤醒等待的生产者。

关键点

线程同步：
- 使用 synchronized 关键字确保对缓冲区的操作是线程安全的。
- 生产者和消费者通过 wait() 和notifyAll() 实现线程间的通信。
缓冲区的作用：
- 缓冲区作为共享资源，协调了生产者和消费者的操作。
- 生产者将产品放入缓冲区，消费者从缓冲区取出产品。
线程通信：
- 当缓冲区满时，生产者会等待，直到消费者消费产品后唤醒它。
- 当缓冲区为空时，消费者会等待，直到生产者生产产品后唤醒它。
改进点：
- 在消费者消费完产品后，如果发现缓冲区为空，会立即通知生产者生产商品，确保缓冲区不会长时间处于空的状态。

方式2代码

package com.kuang.thread;//测试生产者消费者问题2：信号灯法，标志位解决
//并发协作模型“生产者/消费者模式” --》信号灯法
public class TestPC2 {public static void main(String[] args) {TV tv = new TV();new Player(tv).start();new Watcher(tv).start();}
}//生产者--》演员
class Player extends Thread{TV tv;public Player(TV tv){this.tv = tv;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {if (i%2==0){this.tv.play("快乐大本营");}else {this.tv.play("抖音-记录美好生活");}}}
}//消费者--》观众
class Watcher extends Thread{TV tv;public Watcher(TV tv){this.tv = tv;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {tv.watch();}}
}//产品--》节目
class TV{//演员表演，观众等待//观众观看，演员等待String voice;//表演的节目boolean flag = true;//定义标志词flag//表演public synchronized void play(String voice){if (!flag){//如果flag为假try {this.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("演员表演了：" + voice);//通知观众观看this.notifyAll();//通知唤醒this.voice = voice;this.flag = !this.flag;}//观看public synchronized void watch(){if (flag) {try{this.wait();} catch (InterruptedException e){e.printStackTrace();}}System.out.println("观众观看了：" + voice);//通知演员表演this.notifyAll();this.flag = !this.flag;}
}

这段代码实现了一个简单的生产者-消费者模型，使用了“信号灯法”（也称为标志位法）来协调生产者和消费者之间的同步。代码的核心思想是通过一个共享的标志位（flag）来控制生产者和消费者的执行顺序，确保生产者和消费者交替执行。

代码结构分析

TestPC2 类：
- 这是程序的入口类，包含 main 方法。
- 在 main 方法中，创建了一个 TV 对象（共享资源），并启动了一个生产者线程（Player）和一个消费者线程（Watcher）。
Player 类：
- 这是生产者线程类，继承自 Thread。
- 在 run 方法中，生产者会循环 20 次，交替生产两种节目：“快乐大本营”和“抖音-记录美好生活”。
- 生产者通过调用 TV 对象的 play 方法来生产节目。
Watcher 类：
- 这是消费者线程类，继承自 Thread。
- 在 run 方法中，消费者会循环 20 次，调用 TV 对象的 watch 方法来消费节目。
TV 类：
- 这是共享资源类，包含了生产者和消费者共享的数据和方法。
- voice 字段表示当前播放的节目。
- flag 字段是一个标志位，用于控制生产者和消费者的执行顺序。
- play 方法和 watch 方法都是同步方法（synchronized），确保同一时间只有一个线程可以访问这些方法。

代码执行流程

生产者（Player）执行流程：
- 生产者调用 play 方法时，首先检查 flag 是否为 false。如果 flag 为 false，表示消费者正在消费，生产者需要等待（调用 wait 方法）。
- 如果 flag 为 true，生产者可以执行生产操作，输出节目名称，并调用 notifyAll 方法唤醒等待的消费者线程。
- 生产完成后，生产者将 flag 设置为 false，表示消费者可以开始消费。
消费者（Watcher）执行流程：
- 消费者调用 watch 方法时，首先检查 flag 是否为 true。如果 flag 为 true，表示生产者正在生产，消费者需要等待（调用 wait 方法）。
- 如果 flag 为 false，消费者可以执行消费操作，输出当前播放的节目名称，并调用 notifyAll 方法唤醒等待的生产者线程。
- 消费完成后，消费者将 flag 设置为 true，表示生产者可以开始生产。

关键点

synchronized 关键字：确保 play 和 watch 方法是线程安全的，同一时间只有一个线程可以执行这些方法。
wait 和 notifyAll 方法：用于线程间的通信和同步。wait 方法使当前线程进入等待状态，直到其他线程调用 notifyAll 方法唤醒它。
flag 标志位：用于控制生产者和消费者的执行顺序。flag 为 true 时，生产者可以生产；flag 为 false 时，消费者可以消费。

总结

这段代码通过使用 synchronized、wait 和 notifyAll 方法，以及一个标志位 flag，实现了一个简单的生产者-消费者模型。生产者和消费者交替执行，确保生产者生产一个节目后，消费者才能消费，反之亦然。这种模式可以有效地解决多线程环境下的同步问题。

线程池

使用线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
可以避免频繁创建销毁、使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：
    提高响应速度（减少了创建新线程的时间）
    降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    便于线程管理（...）
        corePoolSize:核心池的大小
        maximumPoolSize：最大线程数
        keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
    <T>Future<T>submit(Callable<T>task):执行任务，有返回值，一般又来执行Callable
    void shutdown():关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

练习代码：

package com.kuang.thread;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*
线程池
使用线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
可以避免频繁创建销毁、使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。好处：提高响应速度（减少了创建新线程的时间）降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理（...）corePoolSize:核心池的大小maximumPoolSize：最大线程数keepAliveTime：线程没有任务时最多保持多长时间后会终止JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutorvoid execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable<T>Future<T>submit(Callable<T>task):执行任务，有返回值，一般又来执行Callablevoid shutdown():关闭连接池Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池*/
//测试线程池
public class TestPool {public static void main(String[] args) {//1.创建服务，创建线程池//newFixedThreadPool 参数为：线程池大小ExecutorService service = Executors.newFixedThreadPool(10);//创建线程池//执行线程service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());//关闭连接service.shutdownNow();}
}class MyThread implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}
}

这段代码演示了如何使用 Java 的线程池（ExecutorService）来管理和执行多线程任务。线程池是一种用于管理多个线程的机制，它可以避免频繁创建和销毁线程，从而提高程序的性能和资源利用率。

代码结构分析

TestPool 类：
- 这是程序的入口类，包含 main 方法。
- 在 main 方法中，创建了一个固定大小的线程池，并使用线程池执行多个任务。
MyThread 类：
- 这是一个实现了 Runnable 接口的类，表示一个可以被线程执行的任务。
- 在 run 方法中，任务简单地输出当前线程的名称。

代码执行流程

创建线程池：
- 使用 Executors.newFixedThreadPool(10) 创建一个固定大小为 10 的线程池。这意味着线程池中最多可以同时运行 10 个线程。
- ExecutorService 是线程池的接口，Executors 是一个工具类，提供了创建不同类型线程池的静态方法。
提交任务：
- 使用 service.execute(new MyThread()) 方法向线程池提交任务。execute 方法接受一个 Runnable 对象，并将其放入线程池中等待执行。
- 代码中提交了 4 个 MyThread 任务。
任务执行：
- 线程池中的线程会从任务队列中取出任务并执行。每个任务的 run 方法会被调用，输出当前线程的名称。
- 由于线程池的大小是 10，而任务只有 4 个，因此这些任务会被线程池中的线程立即执行。
关闭线程池：
- 使用 service.shutdownNow() 方法关闭线程池。shutdownNow 会尝试停止所有正在执行的任务，并返回等待执行的任务列表。
- 关闭线程池后，不能再向线程池提交新的任务。

关键点

线程池的优势：
- 提高响应速度：线程池中的线程是预先创建好的，任务提交后可以直接执行，减少了创建线程的时间。
- 降低资源消耗：线程池中的线程可以重复利用，避免了频繁创建和销毁线程的开销。
- 便于线程管理：线程池提供了对线程的统一管理，可以控制线程的数量、生命周期等。
ExecutorService 接口：
- execute(Runnable command)：执行一个没有返回值的任务。
- submit(Callable<T> task)：执行一个有返回值的任务，返回一个 Future 对象。
- shutdown()：平缓关闭线程池，等待所有任务执行完毕。
- shutdownNow()：立即关闭线程池，尝试停止所有正在执行的任务。
Executors 工具类：
- 提供了创建不同类型线程池的静态方法，如 newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor 等。

总结

这段代码展示了如何使用 Java 的线程池来管理和执行多线程任务。通过使用线程池，可以有效地管理线程资源，避免频繁创建和销毁线程，从而提高程序的性能和资源利用率。线程池是多线程编程中非常重要的工具，特别适用于需要处理大量短期任务的场景。

线程通信

方式1代码

代码结构

代码逻辑

1. 生产者逻辑

2. 消费者逻辑

3. 缓冲区逻辑

代码执行流程

关键点

方式2代码

代码结构分析

代码执行流程

关键点

总结

线程池

代码结构分析

代码执行流程

关键点

总结

相关文章：