java-併發集合-併發隊列 ConcurrentLinkedQueue 演示

java-併發集合-併發隊列 ConcurrentLinkedQueue 演示


目標：模擬 5 個線程同時併發讀取“併發隊列”，並使用 CountDownLatch 類協助計算消費耗時。

package me.grass.demo.concuronte;


import java.util.Date;


/**
 * 同步隊列 java.util.concurrent.ConcurrentLinkedQueue 使用
 * 
 */
public class ConcurrentLinkedQueueDemo {
	/**
	 * 生產者快，消費者慢
	 * @param args
	 * @throws InterruptedException
	 *  @author xxj
	 */
	public static void main(String[] args) throws InterruptedException {
		LinkedBlockingQueueDemo._lCountDownLatch.countDown();
		Date before=new Date();
		int pTotalThread =100; //最大線程數（生產者）
		int cTotalThread =5; //活動線程數（消費者）
		int pActivities=50; //最大線程數（生產者）
		int cActivities=5; //活動線程數（消費者）
		_lCountDownLatch = new CountDownLatch(pTotalThread+cTotalThread);
		
		startProducer(pActivities,pTotalThread);
		startConsumer(cActivities,cTotalThread);
		
		_lCountDownLatch.await();//等待所有線程完成
		Date after = new Date();


		System.out.println("隊列爲空："+_queue.isEmpty());
		System.out.println("耗時："+((after.getTime()-before.getTime())/1000));
		System.out.println("同步隊列："+_lCountDownLatch.getCount());		
	}
	static java.util.concurrent.CountDownLatch _lCountDownLatch;
	static java.util.concurrent.ConcurrentLinkedQueue<Integer> _queue = 
			new ConcurrentLinkedQueue<Integer>();
			
	static void startProducer(int active,int totalThread) throws InterruptedException{
		java.util.concurrent.ExecutorService pool = Executors.newFixedThreadPool(active);
		int size =1024*1024*10;//產生 3 M 數據
		Thread thread ;
		for(int i=0;i<totalThread;i++){
			thread = new Thread(new producer(i,size));
			pool.execute(thread);
		}
	}
	static void startConsumer(int active,int totalThread) throws InterruptedException{
		java.util.concurrent.ExecutorService pool = Executors.newFixedThreadPool(active);		
		Thread thread ;
		//啓動x個消費者
		for(int i=0;i<totalThread;i++){
			thread = new Thread(new consumer());
			pool.execute(thread);
		}
	}
	/**
	 * 生產者
	 * @author xxj 
	 *
	 */
	static class producer implements Runnable{
		public producer(int key,int size){
			_size=size;
			_key=key;
		}
		int _key;
		int _size;
		public void run() {
			ConcurrentLinkedQueueDemo._queue.add(_key);//生產
			System.out.println("已創建："+_key);
			ConcurrentLinkedQueueDemo._lCountDownLatch.countDown();//線程同步遞減
		}
	}
	/**
	 * 消費者
	 * @author xxj
	 *
	 */
	static class consumer implements Runnable{
		public consumer(){
		}
		public void run() {
			//循環消費，直到隊列內容爲空
			while(!ConcurrentLinkedQueueDemo._queue.isEmpty()){
				Integer nInteger = ConcurrentLinkedQueueDemo._queue.poll();//消費
				System.err.println("消費："+nInteger);
				try {
					Thread.sleep(200);//每次消費等一會兒
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			ConcurrentLinkedQueueDemo._lCountDownLatch.countDown();//線程同步遞減
		}
	}
}