Java 消息队列-Java并发编程

ArrayBlockingQueue：基于数组实现的一个阻塞队列，在创建ArrayBlockingQueue对象时必须制定容量大小。并且可以指定公平性与非公平性，默认情况下为非公平的，即不保证等待时间最长的队列最优先能够访问队列。
 
　　LinkedBlockingQueue：基于链表实现的一个阻塞队列，在创建LinkedBlockingQueue对象时如果不指定容量大小，则默认大小为Integer.MAX_VALUE。
 
　　PriorityBlockingQueue：以上2种队列都是先进先出队列，而PriorityBlockingQueue却不是，它会按照元素的优先级对元素进行排序，按照优先级顺序出队，每次出队的元素都是优先级最高的元素。注意，此阻塞队列为无界阻塞队列，即容量没有上限（通过源码就可以知道，它没有容器满的信号标志），前面2种都是有界队列。
 
　　DelayQueue：基于PriorityQueue，一种延时阻塞队列，DelayQueue中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue也是一个无界队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。

　　功能说明：一个日志接口，考虑到系统日志量提交有可能会阻塞，这里引入了线程池（生存者与消费者模式）来维护日志队列的发送。一个发送消息模块将消息发送到消息队列中，无需等待返回结果，发送模块继续执行其他任务。消息队列中的指令由线程池中的线程来处理。使用一个Queue来存放线程池溢出时的任务

package com.messageQueue.tools;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolManager {

	private static ThreadPoolManager tpm = new ThreadPoolManager();//单例
	
	private final static int CORE_POOL_SIZE =4;//线程池维护线程的最小数量。
	
	private final static int  MAX_POOL_SIZE = 10;//线程池维护线程的最大数量。
	
	private final static int KEEP_ALIVE_TIME = 0;//线程池维护线程所允许的空闲时间。
	
	private final static int WORK_QUEUE_SIZE = 10;//线程池所使用的缓冲队列大小。
	
	Queue msgQueue = new LinkedList();//消息缓冲队列
	
	//访问消息缓存的调度线程
	//查看是否有待定请求，如果有，则创建一个新的AccessDBThread并添加到线程池中。
	final Runnable accessBufferThread = new Runnable() {
		
		public void run() {
			
			if(hasMoreAcquire()) {
				String msg = (String)msgQueue.poll();
				threadPool.execute(new AccessDBThread(msg));
			}
		}
	};
	
	final RejectedExecutionHandler handler = new RejectedExecutionHandler() {
		
		public void rejectedExecution(Runnable arg0, ThreadPoolExecutor arg1) {
				System.out.println(((AccessDBThread)arg0).getMsg()+"消息放入队列中重新等待执行");		
				msgQueue.offer(((AccessDBThread)arg0).getMsg());
		}
	};
	
	//管理工作线程的线程池
	final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue(WORK_QUEUE_SIZE),this.handler);
	
	
	//调度线程池
	final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(100);
	
	final ScheduledFuture taskHandler = scheduler.scheduleAtFixedRate(accessBufferThread, 0, 1, TimeUnit.SECONDS);
	
	public static ThreadPoolManager newInstance() {
		return tpm;
	}
	
	private ThreadPoolManager(){}
	
	private boolean hasMoreAcquire(){
		return !msgQueue.isEmpty();
	}
	
	public void addLogMsg(String msg) {
		threadPool.execute(new AccessDBThread(msg));
	}
}

　　

package com.messageQueue.tools;
/**
 * 
 * 工作线程
 *
 */
public class AccessDBThread implements Runnable{

	private String msg;
	
	public AccessDBThread() {
		
	}
	
    public AccessDBThread(String msg) {
		this.msg = msg;
	}

	public void run() {
			//向数据库中添加MSG变量值
		System.out.println("Added the message："+msg+" into the Database");
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}
	
	

}

　　

package com.messageQueue.test;

import com.messageQueue.tools.ThreadPoolManager;
//sendMsg方法不断的向ThreadPoolManager发送数据
public class TestDriver {

	ThreadPoolManager tpm = ThreadPoolManager.newInstance();
	
	public void sendMsg(String msg) {
		tpm.addLogMsg(msg+"记录一条日志");
	}
	
	public static void main(String[] args) {
		for(int i=0;i<1000;i++) {
			new TestDriver().sendMsg(Integer.toString(i));
		}
	}
}

　　转载于：http://www.cnblogs.com/molao-doing/articles/4445045.html