双缓冲队列尝试

提出背景：
在C/S模式的系统里面，服务器端的主线程，除了要接收消息之外，还要处理消息。这使得主线程的工作量不但很大，而且工作很繁杂。这种情况在软件设计的角度来看，是很不好的：第一，这样让主线程类看起来异常的臃肿和难易阅读，第二，软件设计追求的目标是“尽量让每个类处理的工作都很单一，这样便于以后的调试和进一步对程序的扩展和移植”，这样的设计背离了软件设计中“模块化设计”的原则。
为此，很多程序员会设计一个全局的LinkedBlockingQueue对象来存放服务器主线程所收到的消息，即主线程收到消息之后，不做任何业务逻辑处理，直接put到阻塞队列中去，然后再启动一个处理消息的线程来从阻塞队列中take消息，这样就让服务器端程序大大解耦了，也便于阅读了，当然，最重要的是，效率也提高了不少。
但是在负荷量很大的系统里面，这样做仍然不是最好的办法。上面的解决办法中，仍然存在两个线程竞争一个资源的情况，即仍然存在同步的问题，只是LinkedBlockingQueue在底层进行了处理，在负荷量很大，并且要频繁访问同一个LinkedBlockingQueue对象的情况下，会使得效率较原始情况没有多大的提高。分析一下：主线程每次拿到消息M，都要put到LinkedBlockingQueue对象中，这样在LinkedBlockingQueue底层就要处理一次线程同步问题，当工作量很大很频繁的时候，这样的操作未免就显得有些累赘了，浪费了很多的时间和资源。同样在处理线程，每次take一个消息M，就会处理一次线程同步，同样降低了效率。注意，只是在负荷量很大的情况下(如中国移动CMPP短信网关)，这样的弱点才会很明显地暴露出来。

问题分析：
暴露出了问题，就需要我们想办法去解决，通过上面的分析，发现瓶颈在于，我们是对同一个LinkedBlockingQueue进行的操作，才会引起这么多的滞后。那么能不能试着去用两个LinkedBlockingQueue对象进行操作呢？一个专门给主线程put，另外一个专门给处理线程take和处理，当他们处理完了，再来交换？这样的话，就保障了基本上在每个时刻，每个线程都是在处理自己独自占有的资源，没有引发同步问题。这称之为：双缓冲队列。
当然，上面的解决方案是在一种很理想的情况下，即两个队列，在同一时刻被放满和取空，这样他们在程序运行过程中所达到的效率是最高的，因为没有任何消息被延后处理。所有消息都按照原定计划被处理了。现实情况往往没有这般顺利，但是上面的方案也不失为我们提供了一种解决思路，这其中还涉及到很多的处理机制。为了分析方便，我们暂且将两个LinkedBlockingQueue对象分别称之为LP(主线程控制的专门put的队列)，LT(处理线程控制的，专门take的队列)。
第一，    LP和LT队列什么时候才进行交换？肯定是在LT将所有的消息处理完了之后才进行交换，如果LT里面的消息都没有处理完就被交换了，那有可能LT里面的消息有些几年甚至永远不会被处理，这样的系统是无法投入使用的。
第二，    如果在LT处理完了，LP中还没有收到任何消息会怎么办？这是一种很极端的情况，但是也必须考虑到，延伸一下，如果LT里面的消息处理完了，而LP里面却只有一两条消息，该怎么办？要继续交换，还是等待一段时间以后再进行交换？在这里，笔者采用的是前者。目的是为了让消息都能及时地被处理。

问题解决：

首先我们来看看不使用双缓冲机制的程序：

package cn.netjava.lbq.copy;
//从单缓冲队列中取出玩具对象

public class Kid extends Thread {
	long time1 = System.currentTimeMillis();
	int count = 0;
	public void run() {
		while(true){
		try {
		    Tools.lT.take();
			count++;
//计算取100000个所需要的时间
			if(count==100000){
				System.out.println(System.currentTimeMillis()-time1);
				Thread.sleep(100000);
			}
			System.out.println("玩完一个玩具");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		}
		}

}

package cn.netjava.lbq.copy;
//存放玩具对象的的队列
import java.util.concurrent.LinkedBlockingQueue;

public class Tools {
	public static LinkedBlockingQueue<Tool>lT = new LinkedBlockingQueue<Tool>(10000);
	
}

package cn.netjava.lbq.copy;

public class MainTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Factory f = new Factory();
		f.start();
		Kid k = new Kid();
		k.start();
		
	}

}

 取出100000个玩具的时间为：3609ms

再来看看使用双缓冲队列的情况，toy类就不再贴出了。

看其他类，中间做了一些改动

package cn.netjava.lbq;

import java.util.concurrent.LinkedBlockingQueue;

public class Tools {
	public static LinkedBlockingQueue<Tool>lT = new LinkedBlockingQueue<Tool>(10000);
	public static LinkedBlockingQueue<Tool>lP = new LinkedBlockingQueue<Tool>(10000);
}

package cn.netjava.lbq;


public class Kid extends Thread {
	long time1 = System.currentTimeMillis();
	int count = 0;
	public void run() {
		while(true){
		try {
			 Tools.lT.take();
			count++;
			
			if(count==10000){
			System.out.println(System.currentTimeMillis()-time1);
			Thread.sleep(100000);
			}
			System.out.println("玩完一个玩具");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		}
		}

}

package cn.netjava.lbq;

import java.util.concurrent.LinkedBlockingQueue;

public class Factory extends Thread{
	

	public void run(){
		while(true){
		Toy t = new Toy ();
		t.setName("玩具");
		try {
			Tools.lP.put(t);
			System.out.println("生产出一个玩具");
		} catch (InterruptedException e) {
			e.printStackTrace();
	 	}
		 }
	}
}

	package cn.netjava.lbq;

import java.util.concurrent.LinkedBlockingQueue;
	/**
	 * 定义一个双缓冲队列
	 * @author Irving
	 * @time  2009-9-16----上午10:25:49
	 *
	 */
	public class DoubleBufferList {
	
		private LinkedBlockingQueue<Object> lP;
		private LinkedBlockingQueue<Object> lT;
		private int gap;
		/**
		 * 构造方法
		 * @param lP 用来存放对象的阻塞队列
		 * @param lT 用来取对象的阻塞队列
		 * @param gap 交换的间隔
		 */
		
		public DoubleBufferList(LinkedBlockingQueue  lP
				,LinkedBlockingQueue  lT,int gap){
			this.lP=lP;
			this.lT=lT;
			this.gap=gap;
		}
		
		public void check(){
			Runnable runner = new Runnable(){
				public void run() {
					while(true){
				if(lT.size()==0){
					synchronized(lT){
					synchronized(lP){
					lT.addAll(lP);
					}
					lP.clear();
					}
				}				try {
					Thread.sleep(gap);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
					}	
					
				}				
			};
			Thread thread = new Thread(runner);
			thread.start();
		}
		
	}

package cn.netjava.lbq;

public class MainTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Factory f = new Factory();
		f.start();
		Kid k = new Kid();
		k.start();
		new DoubleBufferList(Tools.lP,Tools.lT,1).check();
	}

}

同样100000个玩具对象，使用的时间是3469ms，大约节约了200ms

在使用双缓冲队列的时候，要注意调试监测线程的监控时间间隔和阻塞队列的大小，这些都是影响运行速度的关键因素。