java线程池的使用学习
1. 线程池的创建
线程池的创建使用ThreadPoolExecutor类，有利于编码时更好的明确线程池运行规则。
//构造函数
/**
* 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:<br>
* {@code corePoolSize < 0}<br>
* {@code keepAliveTime < 0}<br>
* {@code maximumPoolSize <= 0}<br>
* {@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<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
参数含义
(1) 核心线程数corePoolSize： 保持在池中的线程数
(2) 最大线程数maximumPoolSize
(3) 保活时间keepAliveTime： 线程数大于corePoolSize，闲置线程最大空闲时间
(4) 时间单位unit
(5) 阻塞队列workQueue
java.util.concurrent.BlockingQueue主要实现类有：
- ArrayBlockingQueue： 数组结构有界阻塞队列，FIFO排序。其构造函数必须设置队列长度。
- LinkedBlockingQueue：链表结构有界阻塞队列，FIFO排序。队列默认最大长度为Integer.MAX_VALUE,故可能会堆积大量请求，导致OOM。
- PriorityBlockingQueue：支持优先级排序的无界阻塞队列。默认自然顺序排列，可以通过比较器comparator指定排序规则。
- DelayQueue：支持延时获取元素的无界阻塞队列。队列使用PriorityQueue实现。
(6) 线程创建接口threadFactory
- 默认使用Executors.defaultThreadFactory()。
- 可以自定义ThreadFactory实现或使用第三方实现，方便指定有意义的线程名称。
import com.google.common.util.concurrent.ThreadFactoryBuilder;
...
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("my-pool-%d").build();
public class MyThreadFactory implements ThreadFactory {
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
MyThreadFactory(String namePrefix) {
this.namePrefix = namePrefix+"-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread( r,namePrefix + threadNumber.getAndIncrement());
if (t.isDaemon()) {
t.setDaemon(true);
}
if (t.getPriority() != Thread.NORM_PRIORITY) {
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
}
(7) 饱和策略handler
- ThreadPoolExecutor.AbortPolicy()：终止策略(默认) ， 抛出java.util.concurrent.RejectedExecutionException异常。
- ThreadPoolExecutor.CallerRunsPolicy(): 重试添加当前的任务，他会自动重复调用execute()方法。
- ThreadPoolExecutor.DiscardOldestPolicy(): 抛弃下一个即将被执行的任务，然后尝试重新提交新的任务。最好不和优先级队列一起使用，因为它会抛弃优先级最高的任务。
- ThreadPoolExecutor.DiscardPolicy(): 抛弃策略， 抛弃当前任务。
2. 线程池的运行规则
execute添加任务到线程池:
一个任务通过execute(Runnable)方法被添加到线程池。任务是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。
线程池运行规则:
当一个任务通过execute(Runnable)方法添加到线程池时：
-
如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
-
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
-
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
-
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
-
也就是：处理任务的优先级为：
核心线程corePoolSize - > 任务队列workQueue - > 最大线程maximumPoolSize
如果三者都满了，使用handler策略处理该任务。
- 当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
// execute方法源码实现(jdk1.8)
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
3. 线程池的关闭
通过调用线程池的shutdown或shutdownNow方法来关闭线程池。
- shutdown：将线程池的状态设置成SHUTDOWN状态，然后interrupt空闲线程。
- shutdownNow：线程池的状态设置成STOP，然后尝试interrupt所有线程，包括正在运行的。
关于线程池状态，源码中的注释比较清晰：
再看一下源代码：
// 在关闭中，之前提交的任务会被执行（包含正在执行的，在阻塞队列中的），但新任务会被拒绝。
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 状态设置为shutdown
advanceRunState(SHUTDOWN);
// interrupt空闲线程
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 尝试终止线程池
tryTerminate();
}
其中，interruptIdleWorkers()方法往下调用了interruptIdleWorkers(), 这里w.tryLock()比较关键。
中断之前需要先tryLock()获取worker锁，正在运行的worker tryLock()失败(runWorker()方法会先对worker上锁)，故正在运行的worker不能中断。
// 尝试停止所有正在执行的任务，停止对等待任务的处理，并返回正在等待被执行的任务列表
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 状态设置为STOP
advanceRunState(STOP);
// 停止所有线程 interruptWorkers逻辑简单些，循环对所有worker调用interruptIfStarted().(interrupt所有线程)
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
4. 线程池的使用场合
（1）单个任务处理的时间比较短；
（2）需要处理的任务数量大；
5. 线程池大小的设置
可根据计算任务类型估算线程池设置大小：
cpu密集型：可采用Runtime.avaliableProcesses()+1个线程；
IO密集型：由于阻塞操作多，可使用更多的线程，如2倍cpu核数。
6 实现举例
场景: ftp服务器收到文件后，触发相关搬移/处理操作。
public class FtpEventHandler extends DefaultFtplet {
@Override
public FtpletResult onUploadEnd(FtpSession session, FtpRequest request)
throws FtpException, IOException {
// 获取文件名
String fileName = request.getArgument();
Integer index = fileName.lastIndexOf("/");
String realFileName = fileName.substring(index + 1);
index = realFileName.lastIndexOf("\\");
realFileName = realFileName.substring(index + 1);
// **处理文件**
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 50, 10,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3));
threadPool.execute(new fileSenderThread(realFileName));
return FtpletResult.DEFAULT;
}
}
Spring也提供了ThreadPoolTaskExecutor
<!--spring.xml配置示例-->
<bean id="gkTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="allowCoreThreadTimeOut" value="true"/>
<property name="corePoolSize" value="10"/>
<property name="maxPoolSize" value="50"/>
<property name="queueCapacity" value="3"/>
<property name="keepAliveSeconds" value="10"/>
<property name="rejectedExecutionHandler"
value="#{new java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy()}"/>
<property name="threadNamePrefix" value="gkTaskExecutor"/>
</bean>
//java代码中注入bean
@Autowired
@Qualifier("gkTaskExecutor")
private ThreadPoolTaskExecutor gkTaskExecutor;
end.
eaglediao
