通过ThreadPoolExecutor定制线程池

通过ThreadPoolExecutor定制线程池，包含了定制ThreadFactory、RejectedExecutionHandler 。

package com.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义线程池
 * 
 * @author lenovo
 *
 */
public class ThreadPoolDemo {

	public static class MyTask implements Runnable {
		private String name;

		public MyTask(String name) {
			this.name = name;
		}

		@Override
		public void run() {
			System.err.println(
					System.currentTimeMillis() + "|Threa name:" + name + "|Thread ID" + Thread.currentThread().getId());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 自定义线程创建工厂
	 * 
	 * @author lenovo
	 *
	 */
	public static class MyThreadFactory implements ThreadFactory {
		private final AtomicInteger threadNumber = new AtomicInteger(1);
		private final ThreadGroup group;
		private final String namePrefix;

		public AtomicInteger getThreadNumber() {
			return threadNumber;
		}

		public ThreadGroup getGroup() {
			return group;
		}
		public String getNamePrefix() {
			return namePrefix;
		}

		MyThreadFactory(String groupName, String poolName) {
			// 设置线程组名
			group = new ThreadGroup(groupName);
			namePrefix = poolName + "-thread-";
		}

		@Override
		public Thread newThread(Runnable r) {
			Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement());
			// 设置为守护线程
			t.setDaemon(true);
			// 设置线程优先级
			t.setPriority(Thread.MAX_PRIORITY);
			System.out.println("create " + t);
			return t;
		}

	}

	/**
	 * 自定义线程拒绝策略
	 * 
	 * @author lenovo
	 *
	 */
	public static class MyRejectedExecutionHandler implements RejectedExecutionHandler {

		@Override
		public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
			MyThreadFactory threadFactory = (MyThreadFactory) executor.getThreadFactory();
			System.err.println(r.toString() + " is discard" + "-" + threadFactory.getNamePrefix() + "-"
					+ threadFactory.getGroup().getName());
		}

	}

	public static void main(String[] args) throws InterruptedException {

		int poolSize = Runtime.getRuntime().availableProcessors();
		/**
		 * 利用自定义的线程创建工厂、拒绝策略自定义线程池
		 */
		ExecutorService es = new ThreadPoolExecutor(poolSize, poolSize * 2, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue<Runnable>(10), new MyThreadFactory("MyThreadGroup", "MyPool"),
				new MyRejectedExecutionHandler());

		for (int i = 0; i < 50; i++) {
			MyTask task = new MyTask("MyTask-" + i);
			// es.submit(task);
			es.execute(task);
			Thread.sleep(10);
		}
	}
}