【学习笔记】线程（八）之线程通信
生产者消费者问题
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间互相依赖，互为条件
-
对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
-
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
-
-
synchronized 可阻止并发更新同一共享资源，实现了同步
-
synchronized 不能用来实现不同线程之间的消息传递（通信）
-
在Object 类中有两个关于线程通信的方法：
wait() //表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout) //指定等待的毫秒数
notify() //唤醒一个处于等待状态的线程
notifyAll() //唤醒同一个对象上所有调用wait() 方法的线程，优先级别高的线程优先调度
注意：这两个方法，都只能在同步方法或同步代码块中使用，否则会抛出异常IIIegaIMonitorStateException
解决方式1：管程法
并发协作模型”生产者/消费者模式“--->管程法
-
生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
-
消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
-
缓冲区：消费者不能直接使用生产者的数据，它们之间有个”缓冲区“
生产者将生产好的数据放入缓冲区，消费者从缓冲区中拿出数据
package com.thread.cooperate;
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
//产品
class Chicken{
int id;
public Chicken(int id) {
this.id = id;
}
}
//生产者
class Productor extends Thread{
SynContainer synContainer;
public Productor(SynContainer synContainer) {
this.synContainer = synContainer;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
synContainer.push(new Chicken(i));
System.out.println("生产了" + i +"只鸡");
}
}
}
//消费者
class Consumer extends Thread{
SynContainer synContainer;
public Consumer(SynContainer synContainer) {
this.synContainer = synContainer;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("消费了"+synContainer.pop().id+"只鸡" );
}
}
}
//缓冲区
class SynContainer{
Chicken[] chickens = new Chicken[10];
int count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken) {
//如果容器满了，需要生产者等待
while (count == chickens.length){
try {
this.wait();
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有满，需要生产者放入产品
chickens[count] = chicken;
count++;
//通知消费者来消费
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop(){
//等待生产者生产
while(count <= 0){
try {
this.wait();
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//消费
count--;
Chicken chicken = chickens[count];
//通知生产者生产
this.notifyAll();
return chicken;
}
}
在这个案例中，生产者和消费者的运行速度不同，所以可能会出现生产者还没有打印出生产第十只鸡，然而消费者却已经打印出消费了第十只鸡的情况
还有一种情况：消费者已经消费了第9只鸡，却没有打印，而生产者被通知可以生产后，立马生产并打印出了第十只鸡，所以造成了生产者连续生产了11只鸡的情况
所以我在程序中加入了sleep，分别在生产者和消费者被唤醒后加了100ms,在消费者消费前加了100ms，这样就不会出现上述问题了
当有多个消费者或生产者时，在判断容器是否满了，或者空了时，不要用if来判断，要用while，因为存在虚假唤醒。
-
虚假唤醒：
-
在一般条件下，当线程进入wait状态下，需要其他线程调用notify方法后，线程才会从wait方法中返回， 而虚假唤醒是指线程通过其他方式，从wait方法中返回。
-
举一个例子：当购买车票时，线程A买票，如果发现没有余票，则会调用wait方法，线程进入等待队列中，线程B进行退票操作，余票数量加一，然后调用notify 方法通知等待线程，此时线程A被唤醒执行购票操作。如果是按照if(余票数<0)判断，程序按逻辑完全可行。
那么此时线程A的状态应该如下： （1）释放锁并阻塞
（2）等待条件cond发生
（3）获取通知后，竞争获取锁
但如果在B线程退票同时，进来一个线程C，此时由于synchronized，导致C进入阻塞状态，而当B退票后，余票>0，此时C线程立即竞争到锁余票减一，而此时A线程还处于获取竞争锁状态，继续执行，此时余票是没有的，导致系统报出异常。
-
解决方法：
使用which方法代替if方法即可,在每一次调用都判断是否满足条件，但如果一直在which循环中也有缺点，那就是会导致CPU消耗。
解决方式2：信号灯法
设置一个标志位，如果为真就等待，如果为假就通知另一个线程
通过一个演员观众的例子来了解信号灯法
package com.thread.cooperate;
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){
tv.play("声生不息");
}else {
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{
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;
}
}
线程池
-
背景：我们经常创建和销毁、使用特别大量的资源，比如并发情况下的线程，对性能影响特别大
-
思路：我们可以提前创建一些线程，放在线程池中，使用时直接获取，可以比卖你频繁地创建和销毁，实现重复利用
-
好处：
-
提高响应速度
-
降低资源消耗
-
便于线程管理
-
使用线程池：
-
ExecutorService:真正的线程池接口，常见子类ThreadPoolExecutor
-
void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
-
< T >Future <T> submit(Callable<T> task) ：执行任务，有返回值，一般用来执行Callable
-
void shutdown():关闭线程池
-
-
Executor:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
package com.thread.cooperate;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
public static void main(String[] args) {
//创建线程池
//参数是线程池大小
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
