Java并发机制(6)--阻塞队列

Java并发编程:阻塞队列
整理自:博客园-海子-http://www.cnblogs.com/dolphin0520/p/3933404.html

1、什么是阻塞队列
  除了同步容器(Hashtable、Vector)、并发容器(ConcurrentHashMap、CopyOnWriteArrayList)外,还有一种容器就是阻塞队列;
  阻塞队列会在一定条件下对当前线程产生阻塞,条件消失后唤醒被阻塞的线程。
2、几种主要的阻塞队列
  ArrayBlockingQueue:基于数组实现,有界,先进先出
  LinkedBlockingQueue:基于链表实现,有界,先进先出
  PriorityBlockingQueue:基于优先级的,无解,优先级高的先出;
  DelayQueue:延时阻塞,无界,指定一定延时时间
3、非阻塞队列与阻塞队列的方法比较:
  3.1非阻塞队列(如deque,LinkedList,PriorityQueue等)
    add(E e):加入队列末尾,成功返回true,失败抛出异常;
    remove():移除并获取队首元素,为null则抛异常。
    offer(E e):成功返回true,失败返回false,好于add因为它不会只抛一个异常;
    poll():移除并获取队首元素,为空返回null,也好于remove;
    peek():获取队首元素,失败返回null;
    建议使用offer,poll,和peek。
  3.2阻塞队列:
    上述五种,且实现同步;
    put(E e):存入队尾,满则等待;
    take():取队首,队列空则等待;
    offer(E e,long timeout, TimeUnit unit):队尾存,满则等待时间,还不行返回false;
    poll(long timeout, TimeUnit unit):取队首,队列空则等待,时间到达后,返回元素,取不到返回null;
4、阻塞队列的实现原理:
   使用可重入锁ReentrantLock,调用其可中断加锁方法lockInterruptibly()

5、java实例:

//非阻塞队列实现生产者消费者模式
public class Test {
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
     
    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();
         
        producer.start();
        consumer.start();
    }
     
    class Consumer extends Thread{
         
        @Override
        public void run() {
            consume();
        }
         
        private void consume() {
            while(true){
                synchronized (queue) {
                    while(queue.size() == 0){
                        try {
                            System.out.println("队列空,等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.poll();          //每次移走队首元素
                    queue.notify();
                    System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");
                }
            }
        }
    }
     
    class Producer extends Thread{
         
        @Override
        public void run() {
            produce();
        }
         
        private void produce() {
            while(true){
                synchronized (queue) {
                    while(queue.size() == queueSize){
                        try {
                            System.out.println("队列满,等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.offer(1);        //每次插入一个元素
                    queue.notify();
                    System.out.println("向队列取中插入一个元素,队列剩余空间:"+(queueSize-queue.size()));
                }
            }
        }
    }
}

  

//阻塞队列实现生产者消费者模式
public class Test {
    private int queueSize = 10;
    private ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(queueSize);
     
    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();
         
        producer.start();
        consumer.start();
    }
     
    class Consumer extends Thread{
         
        @Override
        public void run() {
            consume();
        }
         
        private void consume() {
            while(true){
                try {
                    queue.take();
                    System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
     
    class Producer extends Thread{
         
        @Override
        public void run() {
            produce();
        }
         
        private void produce() {
            while(true){
                try {
                    queue.put(1);
                    System.out.println("向队列取中插入一个元素,队列剩余空间:"+(queueSize-queue.size()));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  

posted @ 2018-04-22 20:42  一碗雪花  阅读(253)  评论(0编辑  收藏  举报