生产消费模式应用之-使用中断队列实现的日志记录器

包含三个功能类(1~3)以及一个测试类(4):

1. AbstractLogger
2. LoggerConsumption
3. LoggerProduction
4. LoggerTester

相 信看类名大家已经知道了这是个生产-消费的应用。
非常冒昧的把代码加入了com.taobao.log.* 这个package，尽管这只是个测试。

 

以下是代码区域：

 

package com.taobao.log;

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

/**
 * 使用了生产消费模式，并使用了中断队列的日志基类。
 * 
 * @author <a href="mailto:[e-mail]"><b>chenghaojun</b></a>,wangwang:tbjaver(Taobao site)
 * @since 
 * @see LoggerProduction
 * @see LoggerConsumption
 * @version $Id:AbstractLogger.java 2010-3-18 $
 */

public abstract class AbstractLogger implements Runnable {

	/** 初始日志队列大小 */
	private static final int				ITEMS_SIZE			= 100;

	/** 关闭日志标识 */
	protected static final String			SHUTDOWN_REQ		= "SHUTDOWN";

	/** 使用中断队列的日志池，用于追加或者获取数据 */
	private static BlockingQueue<String>	loggerPool			= null;

	private volatile boolean				loggerShuttingDown	= false;
	private volatile boolean				loggerTerminated	= false;

	static {
		loggerPool = new ArrayBlockingQueue<String>(ITEMS_SIZE);
	}

	/** 只允许子类获取的日志池 */
	protected BlockingQueue<String> getLoggerPool() {
		return loggerPool;
	}

	/**
	 * 定义方法模板，强制让子类实现此方法。
	 */
	public abstract void run();

	/**================================================*/
	public boolean isLoggerShuttingDown() {
		return loggerShuttingDown;
	}

	public void setLoggerShuttingDown(boolean loggerShuttingDown) {
		this.loggerShuttingDown = loggerShuttingDown;
	}

	public boolean isLoggerTerminated() {
		return loggerTerminated;
	}

	public void setLoggerTerminated(boolean loggerTerminated) {
		this.loggerTerminated = loggerTerminated;
	}
}

 

 

package com.taobao.log;

/**
 * 生产消费模式中的消费者，不断的从队列中获取并输出日志。
 * 
 * @author <a href="mailto:[e-mail]"><b>chenghaojun</b></a>,wangwang:tbjaver(Taobao site)
 * @since 
 * @see 
 * @version $Id:LoggerConsumption.java 2010-3-18 $
 */

public class LoggerConsumption extends AbstractLogger {
	private static final LoggerConsumption	loggerConsumption	= new LoggerConsumption();

	public static LoggerConsumption getInstance() {
		return loggerConsumption;
	}

	private LoggerConsumption() {
	}

	@Override
	public void run() {
		try {
			String log = null;
			while (!(log = getLoggerPool().take())
					.equalsIgnoreCase(SHUTDOWN_REQ)) {
				System.out.println(log);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			setLoggerTerminated(true);
		}
	}
}

 

 

package com.taobao.log;

/**
 * 生产消费模式中的生产者，不断的往日志队列中加入新的日志
 * @author <a href="mailto:[e-mail]"><b>chenghaojun</b></a>,wangwang:tbjaver(Taobao site)
 * @since 
 * @see 
 * @version $Id:LoggerThread.java 2010-3-18 $
 */

public class LoggerProduction extends AbstractLogger {

	private static final LoggerProduction	loggerProduction	= new LoggerProduction();

	public static LoggerProduction getInstance() {
		return loggerProduction;
	}

	private LoggerProduction() {
	}

	@Override
	public void run() {
		for (;;) {
			String log = "sorry, I come to fuck you!";
			log(log);
		}
	}

	public void log(String str) {
		if (isLoggerShuttingDown() || isLoggerTerminated())
			return;
		try {
			getLoggerPool().put(str);
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
			throw new RuntimeException("程序发生意料之外的中断，错误消息：" + e.getMessage());
		}
	}

	public void shutDown() throws InterruptedException {
		setLoggerShuttingDown(true);
		getLoggerPool().put(SHUTDOWN_REQ);
	}

}

 

 

package com.taobao.log;

/**
 * just a tester
 * @author <a href="mailto:[e-mail]"><b>chenghaojun</b></a>,wangwang:tbjaver(Taobao site)
 * @since 
 * @see 
 * @version $Id:LoggerMain.java 2010-3-18 $
 */

public class LoggerTester {
	public static void main(String[] args) {
		Thread production = new Thread(LoggerProduction.getInstance());
		Thread consumption = new Thread(LoggerConsumption.getInstance());
		production.start();
		consumption.start();
	}
}