线程池懒加载实现初探

单例类：

package com.ldy.utils;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;

public class LazyThreadPool extends ThreadPoolExecutor{
	private static final Logger logger = Logger.getLogger(LazyThreadPool.class);
	/**
	 * 仿Executors.newFixedThreadPool(corePoolSize, threadFactory);
	 * return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
	 * 创建指定大小线程池
	 * @param corePoolSize
	 */
	private LazyThreadPool(int corePoolSize) {
		super(corePoolSize, corePoolSize, 0L, TimeUnit.MILLISECONDS, 
				new LinkedBlockingQueue<Runnable>(), 
				new ThreadFactory() {
			@Override
			public Thread newThread(Runnable r) {
				Thread t = Executors.defaultThreadFactory().newThread(r);
				//t.setDaemon(true);//此线程创建后，设置为后台线程
				logger.info("创建线程："+t);
				return t;
			}
		});
		logger.info("懒实例执行器服务被创建：LazyThreadPool");
	}

	private static class ExecutorServiceHolder {
		private static ExecutorService executorService = new LazyThreadPool(1);//作为单线程池处理任务
	}

	public static ExecutorService getExecutorService() {
		return ExecutorServiceHolder.executorService;
	}
	@Override
	protected void beforeExecute(Thread t, Runnable r) {
		System.out.println(t);
		if(r instanceof AbstractTask){
			logger.info("任务准备执行："+((AbstractTask)r).taskName);
		}
	}

	@Override
	protected void afterExecute(Runnable r, Throwable t) {
		if(r instanceof AbstractTask){
			logger.info("任务执行完成："+((AbstractTask)r).taskName);
		}
	}

	@Override
	protected void terminated() {
		logger.info("线程池退出");
	}
	@Override
	public void execute(Runnable command) {
		// TODO Auto-generated method stub
		super.execute(this.wrapRunnable(command,clientTrace()));
	}
	@Override
	public Future<?> submit(Runnable task) {
		// TODO Auto-generated method stub
		return super.submit(this.wrapRunnable(task,clientTrace()));
	}
	private Exception clientTrace(){
		return new Exception("任务提交所在处。");
	}
	/**
	 * 1、知道异常在哪里抛出的
	 * 2、这个任务到底是在哪里提交的
	 * @param command
	 * @return
	 */
	private Runnable wrapRunnable(final Runnable command,final Exception clientTrace){
		return new Runnable() {
			@Override
			public void run() {
				try{
					command.run();
				}catch(Exception e){
					clientTrace.printStackTrace();//追踪调用所在地
					e.printStackTrace();//防止部分任务运行时异常丢失
					throw e;
				}
			}
		};
	}
	
}

任务抽象：

package com.ldy.utils;
/**
 * 多线程应用基类
 * 任务抽象，作用于：运行时提供任务名称
 * @author ldy
 *
 */
public abstract class AbstractTask implements Runnable{
	protected String taskName;
}

调用示例：

package main;

import com.ldy.utils.AbstractTask;

public class TestTask extends AbstractTask{
	public TestTask() {
		this.taskName = "测试线程池框架";
	}
	@Override
	public void run() {
		try {
			Thread.currentThread().sleep(600);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("执行方法主体");
		System.out.println(2/0);
	}

}

package main;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import com.ldy.utils.LazyThreadPool;

public class TestExecutorService {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Future<?> re = LazyThreadPool.getExecutorService().submit(new TestTask());
		//System.out.println("任务执行完后的结果："+re.get());
		//Executors.newFixedThreadPool(1).submit(new TestTask());
	}
}