Java基础--线程池

简介

线程池可以重用存在的线程,减少对象创建、消亡的开销,性能好。并且可以控制最大并发线程数,提高系统资源利用率,同时避免过多资源竞争,避免阻塞。

java.uitl.concurrent.ThreadPoolExecutor

ThreadPoolExecutor提供了四个构造函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}


public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}


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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
  • corePoolSize //核心线程数量;只有任务来到才会创建线程。
  • maximumPoolSize //线程最大线程数量
  • workQueue //阻塞队列,存储等待执行的任务
  • keepAliveTime //线程中没有任务时,线程最多保持多久就销毁
  • unit //的时间单位
  • threadFactory //线程工厂,用来创建线程
  • rejectHandler //如果阻塞队列满了,并且没有空闲线程,根据这个参数执行拒绝处理任务的策略

1、如果系统中线程数量小于corePoolSize,直接创建新的线程来执行任务(不管是否存在空闲线程);如果线程数量大于corePoolSize,但是小于maximumPoolSize,只有workQueue满了才会创建新的线程;如果系统中线程数量等于maximumPoolSize,maximumPoolSize和corePoolSize相同,workQueue不满,则线程进入workQueue,否则指定策略执行任务。

2、workQueue 是阻塞队列(BlockingQueue)

1
2
3
4
5
ArrayBlockingQueue   //可以限定队列长度
DelayQueue //队内元素必须实现Delayed接口,队列中有元素入队时,只有到达指定延时时间,才会执行任务。
LinkedBlockingQueue //阻塞的线程进入队列中,但这个队列没有最大值,因此设置maximumPoolSize会失效。
PriorityBlockingQueue //优先级阻塞队列
SynchronousQueue //SynchronousQueue是没有缓存的阻塞队列,接收到任务会直接提交给线程处理,如果没有空闲线程,将创建一个,一般使用时将maximumPoolSize设置为Integer.MAX_VALUE

核心参数

  • execute() //提交任务,交给线程池使用
  • submit() //提交任务,能够返回执行结果 execute + Future
  • shutdown() // 关闭线程池,等所有任务都执行完
  • shutdownNow() //关闭线程池,不等待任务执行完
  • getTaskCount() //线程池已执行和未执行的任务总数
  • getCompletedTaskCount() //已完成任务数量
  • getPoolSize() //线程池当前线程数量
  • getActiveCount() //当前线程池中正在执行任务的线程数量

线程池原理

线程池状态

imagepng

  • RUNNING 运行状态,能接受新提交的任务,也能处理阻塞队列中的任务
  • SHUTDOWN 关闭状态,不能接受新提交的任务,但是可以处理阻塞队列中的任务
  • STOP 不能接受新的任务,也不能处理阻塞队列中的任务
  • TIDYING 工作线程为0时进入这个状态

线程池种类

  • Executors.newCachedThreadPool
  • Executors.newFixedThreadPool
  • Executors.newSingleThreadExecutor
  • Executors.newScheduleThreadPool

newCachedThreadPool

创建一个可缓存的线程池,任务增加时则创建线程执行任务,线程空闲60秒则回收线程。

1
2
3
4
5
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}

可以看到最大线程数量是Integer.MAX_VALUE,使用的是SynchronousQueue,因此有任务时不会存在阻塞队列中,会直接创建线程执行。

newFixedThreadPool

1
2
3
4
5
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

定长线程池,使用的是LinkedBlockingQueue阻塞队列,有任务则创建线程,如果达到固定的数量,则存放到阻塞队列中。

newSingleThreadExecutor

创建一个单线程线程池,可以保证线程池中永远有一个线程在工作,保证了任务的顺序性

1
2
3
4
5
6
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}

可以看到,调用了ThreadPoolExecutor,只允许一个线程运行。使用方法:

1
ExecutorService mSingleThreadPool = Executors.newSingleThreadPool();

newScheduleThreadPool

1
2
3
4
5
6
7
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}

创建一个大小无限,可以定时执行的线程池。