java中阻塞队列的实现方式

学习阻塞队列之前需要掌握线程的wait(),notify()以及notifyAll()的相关知识!

①wait()为什么要放置在while循环中,而不是使用if进行判断

②notify()和notifyAll()有什么区别?为什么有时候认为该使用notify()的地方却使用了notifyAll()?

上面这两个问题是我在学习多线程时产生的疑问,我相信也会是大多数人的疑问

下面是相关介绍:

JVM会为一个使用内部锁的对象维护两个集合EntrySet(锁池)和WaitSet(等待池)

• ①EntrySet:线程A持有对象锁,其它线程若想获得该对象锁,只能进入EntrySet,并且处于线程的BLOCKED状态
• ②WaitSet:线程A调用了wait()方法后会释放该对象的锁,进入WaitSet,并且处于线程的WAITING状态

线程B获得对象锁有两个条件:

• ①对象锁已经被释放(持有锁的线程A执行完了synchronized代码块,或者线程A调用了wait方法)
• ②线程B处于RUNNABLE状态

两个集合中的线程在什么条件下可以转变为RUNNABLE状态呢?

• ①EntrySet:当对象锁被释放后,JVM会唤醒EntrySet中某一线程,此线程的状态就由BLOCKED转为RUNNABLE
• ②WaitSet:
•    1>当对象的notify()方法被调用时,JVM会唤醒WaitSet中的某一线程,此线程状态由WAITING转为RUNNABLE
•    2>当对象的notifyAll()方法被调用时,WaitSet中的全部线程都被唤醒,这些线程状态由WAITING转为RUNNABLE
•    3>唤醒后的线程全部进入EntrySet中

当对象锁被释放后,所有处于RUNNABLE状态的线程会共同去竞争该对象锁,竞争失败的线程会在EntrySet中等待下一次机会

疑问解惑:

①wait()为什么要放置在while循环中,而不是使用if进行判断?

那生产者消费者为例,当前无可消费时,调用消费者的wait(),使其进入等待状态,但是消费者线程无法确定其它线程什么时候会被notify.多生产者多消费者的情况下这是无法预知并掌控的,极有可能发生的是唤醒生产者的是另一个生产者,唤醒消费者的是另一个消费者,如果将wait()放在if判断中就会造成过度生产过度消费的情况,典型如IndexOutOfBoundsException的异常。所以所有的java书籍都会建议开发者永远都要把wait()放到循环语句里面

②notify()和notifyAll()有什么区别?为什么有时候认为该使用notify()的地方却使用了notifyAll()?

我们应该尽量使用notifyAll()的原因就是，notify()非常容易导致死锁。当然notifyAll并不一定都是优点，毕竟一次性将Wait Set中的线程都唤醒是一笔不菲的开销，如果你能handle你的线程调度，那么使用notify()也是有好处的

阻塞队列与普通队列的区别:

①当队列为空时,从队列中获取元素的操作将被阻塞

②当队列为满时,向队列中添加元素的操作将被阻塞

一.阻塞队列的wait()和notify()方式实现

package blockqueue;

import java.util.LinkedList;
import java.util.List;

/**
 * 第一种实现阻塞队列的方式是使用wait()和notify()
 */
public class BlockingQueueModeFir {
    //使用list实现阻塞队列
    private List queue = new LinkedList();
    //有界队列上限
    private int limit = 10;
    //阻塞队列构造
    public BlockingQueueModeFir(int limit) {
        this.limit = limit;//指定队列上限
    }

    /**
     * 向阻塞队列中添加元素
     * @param item
     * @throws InterruptedException
     */
    public synchronized void enqueue(Object item) throws InterruptedException {
        //阻塞队列中元素数已达上限,则执行添加元素的线程阻塞
        while (this.queue.size() == this.limit){
            wait();
        }
        //阻塞队列已被清空时,唤醒所有线程
        if (this.queue.size() == 0){
            notifyAll();
        }
        //阻塞队列存在元素且元素数量未达上限,向队列中添加元素
        this.queue.add(item);
    }

    public synchronized Object dequeue() throws InterruptedException {
        //当阻塞队列为空时,无法取出元素,执行等待
        while (this.queue.size() == 0){
            wait();
        }
        //当阻塞队列已满时,唤醒所有线程
        if (this.queue.size() == this.limit){
            notifyAll();
        }
        //阻塞队列存在元素且元素数量未达上限,取出队列中的元素
        return this.queue.remove(0);
    }
}

二.阻塞队列的并发式实现

package blockqueue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * 第二种实现阻塞队列的方式是并发式
 */
public class BlockingQueueModeSec {
    public static void main(String[] args) {
        //缓冲区允许存放3个元素
        final BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(3);

        //开启两个线程向队列中存入数据
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                while(true) {
                    try {
                        Thread.sleep((long) (Math.random()*1000));
                        System.out.println(Thread.currentThread().getName() + "准备放数据"
                                + (queue.size() == 3?"..队列已满，正在等待":"..."));
                        queue.put(1);
                        System.out.println(Thread.currentThread().getName() + "存入数据，"
                                + "队列目前有" + queue.size() + "个数据");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + "准备取数据"
                                + (queue.size() == 0?"..队列已空，正在等待":"..."));
                        queue.take();
                        System.out.println(Thread.currentThread().getName() + "取出数据，"
                                + "队列目前有" + queue.size() + "个数据");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        }).start();
    }
}