细说 Java 线程池

package thread.pool;
//阻塞式队列
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * 此类演示手动创建线程池
 * 核心：线程池执行器
 * @author gavino
 *
 */
public class TestExecutorService {
	public static void main(String[] args) {
		//手动创建一个线程池
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 30L, TimeUnit.SECONDS, 
				new ArrayBlockingQueue<Runnable>(5),new RejectedExecutionHandler() {
			//回调方法
			@Override
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				System.out.println("线程数超过了线程池的容量，拒绝执行任务-->"+r);
				
			}
		});
		//创建线程对象，并把线程对象放在线程池中，并执行  (这样并不等于执行run  )
		threadPool.execute(new TestThread(1));
		threadPool.execute(new TestThread(2));
		threadPool.execute(new TestThread(3));
		threadPool.execute(new TestThread(4));
		threadPool.execute(new TestThread(5));
		threadPool.execute(new TestThread(6));
		threadPool.execute(new TestThread(7));
		threadPool.execute(new TestThread(8));
		threadPool.execute(new TestThread(9));
		threadPool.execute(new TestThread(10));
		threadPool.execute(new TestThread(11));
		threadPool.execute(new TestThread(12));
		threadPool.execute(new TestThread(13));
		threadPool.execute(new TestThread(14));
		threadPool.execute(new TestThread(15));
		threadPool.execute(new TestThread(16));
	}
}
/**
 * 写线程的任务逻辑
 * @author gavino
 *
 */
class TestThread implements Runnable{
	private int num;
	public TestThread(int num) {
		this.num=num;
	}
	@Override
	public void run() {
		try {
			System.out.println("第"+num+"号线程开始执行");
			Thread.sleep(3000);
			System.out.println("第"+num+"号线程执行结束");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}}

//
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
//
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
//
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
//
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
//
public static ExecutorService newWorkStealingPool(int parallelism) {
    return new ForkJoinPool
        (parallelism,
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

//ForkJoinPool:
public ForkJoinPool(int parallelism,
                        ForkJoinWorkerThreadFactory factory,
                        UncaughtExceptionHandler handler,
                        boolean asyncMode) {
        this(checkParallelism(parallelism),
             checkFactory(factory),
             handler,
             asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
             "ForkJoinPool-" + nextPoolId() + "-worker-");
        checkPermission();
    }

public void run() {
    runWorker(this);
}