java 线程池的理解_Java线程池深入理解

package com.coshaho.threadpool;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Executors;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

* 线程池学习

* @author coshaho

*/

public class MyThreadPool

{

/**

* 第一章 线程池初始化

*/

// 核心线程数量

private int corePoolSize;

// 最大线程数量

private int maximumPoolSize;

// 空闲线程存活时间

private long keepAliveTime;

// 空闲线程存活时间单位

private TimeUnit unit;

// 线程阻塞队列

private BlockingQueue workQueue;

/**

* 线程创建工厂，一般自定义，用于封装传入ThreadPool的Runnable任务

* 默认：Executors.defaultThreadFactory()

* public interface ThreadFactory {

* Thread newThread(Runnable r);

* }

*/

private ThreadFactory threadFactory;

// 线程拒绝机制

private RejectedExecutionHandler handler;

public void initThreadPoolExecutor()

{

ThreadPoolExecutor executor = new ThreadPoolExecutor(

corePoolSize,

maximumPoolSize,

keepAliveTime,

unit,

workQueue,

threadFactory,

handler);

// 设置线程池核心线程数

executor.setCorePoolSize(corePoolSize);

// 设置线程池最大线程数

executor.setMaximumPoolSize(maximumPoolSize);

// 初始化一个核心线程

executor.prestartCoreThread();

// 初始化所有核心线程

executor.prestartAllCoreThreads();

// 不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务

executor.shutdown();

// 立即终止线程池，尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

executor.shutdownNow();

}

/**

* 第二章 线程池任务处理机制

* 来了一个任务后的处理机制

* 1、 当线程池线程数量小于corePoolSize时，立即新建一个线程执行任务；

* 2、 当线程池线程数量等于corePoolSize，workQueue不满时，任务入workQueue队列，等待调度；

* 3、 当workQueue满，线程池线程数量小于maximumPoolSize时，新建线程执行任务；

* 4、 当线程池线程数量等于maximumPoolSize，workQueue满时，采用线程拒绝机制处理任务。

*/

/**

* 第三章 线程阻塞队列

* workQueue的类型为BlockingQueue，通常可以取下面三种类型：

* 1、ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；

* 2、LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；

* 3、synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

*/

/**

* 第四章 线程拒绝机制

*/

public void rejectedExecutionHandlerLearn()

{

// 丢弃任务并抛出RejectedExecutionException异常

handler = new ThreadPoolExecutor.AbortPolicy();

// 也是丢弃任务，但是不抛出异常

handler = new ThreadPoolExecutor.DiscardPolicy();

// 丢弃队列最前面的任务，然后重新尝试执行任务(重复此过程)

handler = new ThreadPoolExecutor.DiscardOldestPolicy();

// 由调用线程处理该任务

handler = new ThreadPoolExecutor.CallerRunsPolicy();

}

/**

* 第五章 JDK默认线程池

*/

public void jdkThreadPool()

{

//创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE

Executors.newCachedThreadPool();

//创建容量为1的缓冲池

Executors.newSingleThreadExecutor();

//创建固定容量大小的缓冲池

Executors.newFixedThreadPool(5);

}

/**

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue()));

}

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

*/

/**

* 第六章 线程池大小设置

* 1、 如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1；

* 2、 如果是IO密集型任务，参考值可以设置为2*NCPU。

*/

/**

* 第七章 JDK源码

* Creates a new {@code ThreadPoolExecutor} with the given initial

* parameters.

*

* @param corePoolSize the number of threads to keep in the pool, even

* if they are idle, unless {@code allowCoreThreadTimeOut} is set

* @param maximumPoolSize the maximum number of threads to allow in the

* pool

* @param keepAliveTime when the number of threads is greater than

* the core, this is the maximum time that excess idle threads

* will wait for new tasks before terminating.

* @param unit the time unit for the {@code keepAliveTime} argument

* @param workQueue the queue to use for holding tasks before they are

* executed. This queue will hold only the {@code Runnable}

* tasks submitted by the {@code execute} method.

* @param threadFactory the factory to use when the executor

* creates a new thread

* @param handler the handler to use when execution is blocked

* because the thread bounds and queue capacities are reached

* @throws IllegalArgumentException if one of the following holds:

* {@code corePoolSize < 0}

* {@code keepAliveTime < 0}

* {@code maximumPoolSize <= 0}

* {@code maximumPoolSize < corePoolSize}

* @throws NullPointerException if {@code workQueue}

* or {@code threadFactory} or {@code handler} is null

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler)

*/

}