本文详细探讨了Java中线程通信的问题，介绍了生产者消费者模式的应用场景及其解决方法，包括使用synchronized和wait/notify机制，以及如何通过线程池提高并发性能。
线程通信问题
学习视频地址：狂神说Java
一、线程协作——生产者消费者模式（是问题不是模式）
1、线程通信
-
应用场景：生产者和消费者问题
-
假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。
-
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，只到仓库中的产品被消费者取走为止。
-
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。
-
2、线程通信–分析
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
- 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费。
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
- 在生产者消费者问题中，仅有synchronized是不够的
- synchronized 可阻止并发更新同一个共享资源，实现了同步。
- synchronized 不能用来实现不同线程之间的消息传递（通信）。
3、线程通信–方法
-
Java提供了几个方法解决线程之间的通信问题
方法名 作用 wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁 wait(long timeout) 指定等待的毫秒数 notify() 唤醒一个处于等待状态的线程 notiyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度 注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException。
-
解决方式1
-
并发协作模型“生产者/消费者模式”——>管程法
- 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
- 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
- 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”。
-
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。
//测试生产者/消费者模式——>利用缓冲区解决：管程法 //生产者、消费者、产品、缓冲区 public class TestPC { public static void main(String[] args) { SynContainer container = new SynContainer(); new Producer(container).start(); new Consumer(container).start(); } } //生产者 class Producer extends Thread{ SynContainer container; public Producer(SynContainer container){ this.container = container; } //生产 @Override public void run(){ for (int i = 0; i < 100; i++) { container.push(new Product(i)); System.out.println("生产了" + i +"个产品"); } } } //消费者 class Consumer extends Thread{ SynContainer container; public Consumer(SynContainer synContainer){ this.container = container; } //消费 @Override public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("消费了————>" + container.pop().id + "个产品"); } } } //产品 class Product{ int id;//产品编号 public Product(int id) { this.id = id; } } //缓冲区 class SynContainer{ //需要一个容器大小 Product[] products = new Product[10]; //容器计数器 int pNums = 0; //生产者放入产品 public synchronized void push(Product product){ //判断容器内产品，如果容器满了就需要等待消费者消费 while(pNums == 10){ //通知消费者消费，生产者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //否则放入产品 products[pNums] = product; pNums++; //通知消费者消费 this.notifyAll(); } //消费者消费产品 public synchronized Product pop(){ //判断能否消费 while(pNums == 0){ //通知生产者生产，消费者等待 try { this.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } } //否则消费者消费 pNums--; Product product = products[pNums]; //通知生产者生产 this.notifyAll(); return product; } } -
-
解决方式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; } @Override public 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; } @Override public void run() { for (int i = 0; i < 20; i++) { tv.watch(); } } } //节目 class TV{ //演员表演，关总等待 T //观众观看，演员等待 F String voice;//表演的节目 boolean flag = true; //表演 public synchronized void play(String voice){ //演员等待 if (!flag){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } 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;//标志位取反 } } - 并发协作模型“生产者/消费者模式”——>信号灯法
二、线程池
1、使用线程池
-
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
-
思路：提前创建好多个线程，放入线程中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
-
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小。
- maximumPoolSize：最大线程数。
- keep Alive Time：线程没有任务是最多保持多长时间后会终止。
-
JDK5.0起提供了线程池相关API：ExecutorService和Executors
-
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- < T >Future< T > submit(Callable< T > task)：执行任务，没有返回值，一般用来执行Callable
- void shutdown()：关闭连接池
-
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.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());
//2.关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
