参考并发容器-阻塞队列 第四部分“阻塞队列的实现原理”。
参考代码生产者-消费者
1.缺少wait会出现的问题
三个类：售货员Clerk，工厂Factory，消费者Consumer
Factory和Consumer共享Clerk对象
class Clerk{
//商品数量默认是0,volatile关键字保证内存可见性
private volatile int product=0;
//进货，synchronized关键字保证原子性，互斥性
public synchronized void get(){
if(product>10){
System.out.println("货满了");
}else {
++product;
System.out.println(Thread.currentThread().getName()+"进货"+product);
}
}
//售货
public synchronized void sale(){
if(product<=0){
System.out.println("没货了");
}else{
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
}
}
}
class Factory implements Runnable{
private Clerk clerk;
Factory(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
for(int i=0;i<20;i++){
clerk.get();//进货
}
}
}
class Consumer implements Runnable{
private Clerk clerk;
Consumer(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
for(int i=0;i<20;i++){
clerk.sale();//卖货
}
}
}
public static void main(String[] args) {
Clerk clerk = new Clerk();
Factory factory = new Factory(clerk);
Consumer consumer = new Consumer(clerk);
Thread tf = new Thread(factory);
Thread tc = new Thread(consumer);
tf.start();
tc.start();
}
输出结果：
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-0进货9
Thread-0进货10
Thread-0进货11
货满了
货满了
货满了
货满了
货满了
货满了
货满了
货满了
货满了
Thread-1卖货11
Thread-1卖货10
Thread-1卖货9
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了
- 问题：上述的情况是当没货的时候还会继续调用该方法，从而占用资源，二货满的情况下也会重复调用进货方法，占用资源，这样是不合理的。
- 解决方式：当货满了，应该停止进货，释放锁让消费者消费，当没货了应该停止消费释放锁，让进货，这是我们想要的逻辑。
使用wait()和notifyAll()这两个方法来实现。
class Clerk{
//商品数量默认是0
private volatile int product=0;
//进货
public synchronized void get(){
if(product>10){
System.out.println("货满了");
try {
this.wait();//等待并释放clerk的对象锁，进入线程队列等待被唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
++product;
System.out.println(Thread.currentThread().getName()+"进货"+product);
notifyAll();//唤醒等待的线程
}
}
//售货
public synchronized void sale(){
if(product<=0){
System.out.println("没货了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
notifyAll();
}
}
}
- 结果
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-0进货9
Thread-0进货10
Thread-0进货11
货满了
Thread-1卖货11
Thread-1卖货10
Thread-1卖货9
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
没货了
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
2.线程阻塞无法唤醒
- 当产品为1时，生成者线程生产结束；此时Consumer还处于wait无法得到唤醒。
这种情景对吗？这种问题什么情况下会发生？ - 解决方式：去掉else，每次都会唤醒另外一方的线程。
class Clerk{
//商品数量默认是0
private volatile int product=0;
//进货
public synchronized void get(){
if(product>10){
System.out.println("货满了");
try {
this.wait();//等待并释放clerk的对象锁，进入线程队列等待被唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
++product;
System.out.println(Thread.currentThread().getName()+"进货"+product);
notifyAll();//唤醒等待的线程
}
//售货
public synchronized void sale(){
if(product<=0){
System.out.println("没货了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
notifyAll();
}
}
3.虚假唤醒
Clerk clerk = new Clerk();
Factory factory = new Factory(clerk);
Consumer consumer = new Consumer(clerk);
Thread tf = new Thread(factory);
Thread tc = new Thread(consumer);
Thread tc2 = new Thread(consumer);
tf.start();
tc.start();
tc2.start();
- 会出现负数！
没货了
没货了
Thread-0进货1
Thread-2卖货1
没货了
Thread-1卖货0
没货了
Thread-2卖货-1
没货了
Thread-1卖货-2
没货了
Thread-2卖货-3
没货了
Thread-1卖货-4
没货了
Thread-2卖货-5
没货了
Thread-1卖货-6
- 原因
两个消费者都处于wait状态，然后生产者生产了一个notifyAll，两个消费者同时往下执行，导致product为负数。 - 解决方法：防止虚假唤醒，应该放在循环中，多次进行检查，直到满足条件才进行下一步
4.守护线程解决线程阻塞
- 当多个消费者和一个生产者的时候，生产者有可能先结束循环，但是消费者还没结束，结果到了其他消费者的时候发现product是小于0的于是就wait，程序一直等待得不到结束，就会一直在wait()
- 解决方式
在共享资源clerk类中定义生产者线程标志位，在main线程中创建一个线程设置为守护线程 并启动，在该守护线程中创建匿名内部类Runnable，并在run方法中判断生产者线程isAlive() 。如果生产者线程结束，就把标志位置为false，该标识位和消费者线程的while判断条件中串联，当生产者线程为false的之后短路，使得消费和线程啥都不做，直到线程结束。 - Clerk中设置Factory 线程标志位
private boolean facctoryFlg = true;//工厂线程结束的标志位，为false表示线程执行完毕
public boolean isFacctoryFlg() {
return facctoryFlg;
}
public void setFacctoryFlg(boolean facctoryFlg) {
this.facctoryFlg = facctoryFlg;
}
- Main中创建守护线程
//创建守护线程
Thread daemon = new Thread(new Runnable() {
@Override
public void run() {
while(true){
if(!tf.isAlive()){
clerk.setFacctoryFlg(false);
System.out.println("factory--------------"+tf.isAlive());
break;
}
}
}
});
daemon.setDaemon(true);//设置为守护线程(后台线程)
daemon.start();
- 修改·Clerk的sale方法
public synchronized void sale(){
while(product<=0){
//当Factory线程结束的时候，直接结束sale方法
if(!isFacctoryFlg()){
return;
}
System.out.println("没货了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
notifyAll();
}
