可阻塞的队列BlockingQueue

IT程序员开发必备-各类资源下载清单，史上最全IT资源，个人收藏总结！

   1.什么是可阻塞队列，阻塞队列的作用与实际应用，阻塞队列的实现原理。
   2.阻塞队列与Semaphore有些相似，但也不同，阻塞队列是一方存放数据，另一方释放数据，Semaphore通常则是由同一方设置和释放信号量。

   3.ArrayBlockingQueue   

      BlockingQueue 方法以四种形式出现，对于不能立即满足但可能在将来某一时刻可以满足的操作，这四种形式的处理方式不同：第一种是抛出一个异常，第二种是返回一个特殊值（null 或false，具体取决于操作），第三种是在操作可以成功前，无限期地阻塞当前线程，第四种是在放弃前只在给定的最大时间限制内阻塞。下表中总结了这些方法：

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

        只有put方法和take方法才具有阻塞功能
   4.用3个空间的队列来演示阻塞队列的功能和效果。见:BlockingQueueTest.java
   5.用两个具有1个空间的队列来实现同步通知的功能。见:BlockingQueueCommunication.java

  例子程序:

   BlockingQueueTest.java

package edu.java5.util;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
 * 用3个空间的队列来演示阻塞队列的功能和效果。 
 **/
public class BlockingQueueTest {
	public static void main(String[] args) {
		final BlockingQueue queue = new ArrayBlockingQueue(3);
		for(int i=0;i<2;i++){
			new Thread(){
				public void run(){
					while(true){
						try {
							Thread.sleep((long)(Math.random()*1000));
							System.out.println(Thread.currentThread().getName() + "准备放数据!");
							queue.put(1);
							System.out.println(Thread.currentThread().getName() + "已经放了数据，" + 							
											"队列目前有" + queue.size() + "个数据");
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

					}
				}
				
			}.start();
		}
		
		new Thread(){
			public void run(){
				while(true){
					try {
						//将此处的睡眠时间分别改为100和1000，观察运行结果
						Thread.sleep(100);
						System.out.println(Thread.currentThread().getName() + "准备取数据!");
						queue.take();
						System.out.println(Thread.currentThread().getName() + "已经取走数据，" + 							
									"队列目前有" + queue.size() + "个数据");	
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			
		}.start();			
	}
}
/**
 * 结果:
 *  Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-0已经放了数据，队列目前有1个数据
	Thread-2已经取走数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-1准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-1已经放了数据，队列目前有1个数据
	Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-0已经放了数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-1准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-1已经放了数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-0已经放了数据，队列目前有1个数据
	Thread-2已经取走数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-0已经放了数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-1准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-1已经放了数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-1准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-1已经放了数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-1准备放数据!
	Thread-1已经放了数据，队列目前有1个数据
	Thread-2已经取走数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-0已经放了数据，队列目前有1个数据
	Thread-2已经取走数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-1准备放数据!
	Thread-1已经放了数据，队列目前有1个数据
	Thread-2已经取走数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-2已经取走数据，队列目前有0个数据
	Thread-0已经放了数据，队列目前有0个数据
	Thread-2准备取数据!
	Thread-0准备放数据!
	Thread-0已经放了数据，队列目前有1个数据
	Thread-2已经取走数据，队列目前有0个数据
	Thread-1准备放数据!
	Thread-1已经放了数据，队列目前有1个数据
	Thread-2准备取数据!
  **/

   BlockingQueueCommunication.java

package edu.java5.util;

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

public class BlockingQueueCommunication {

    /**
     * 题目要求:
     *   子线程循环10次，接着主线程循环20次，接着又回到子线程循环10次，接着再回到主线程循环20次，
     *   如此循环50次，请写出程序。
     * 在前面用Condition实现的同步通知的例子的基础上，改为用阻塞队列来实现。
                        第一个线程：A.take()……..B.put()
                        第二个线程：B.take()……..A.put()
     */
    public static void main(String[] args) {
         final Business business = new Business();
         new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    business.sub(i);
                }        
            }
         }).start();
         for (int i = 0; i < 50; i++) {
            business.main(i);
         }
    }
    static class Business{
        BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
        BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);
        //初始化代码，是main线程处于阻塞状态，等待sub线程唤醒
        {
            try {
                queue2.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public  void sub(int loop){
            try {
                queue1.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println("sub thread sequence of "+i+",loop of "+loop);
            }
            try {
                queue2.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public  void main(int loop){
            try {
                queue2.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 20; i++) {
                System.out.println("main thread sequence of "+i+",loop of "+loop);
            }
            try {
                queue1.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
    }   

}