文章目录
1、池状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K7Abs67x-1638586536124)(I:\study\java\note\concurrent\thread-pool\ExecutorService.png)]
ThreadPoolExecutor使用int的高3位来表示线程池状态，低29位表示线程数量。
| 状态名 | 高3位 | 接收新任务 | 处理阻塞任务队列 | 说明 |
|---|---|---|---|---|
| RUNNING | 111 | Y | Y | |
| SHUTDOWN | 000 | N | Y | 不会接收新任务，但是会处理阻塞队列的剩余任务 |
| STOP | 001 | N | N | 会中断正在执行的任务，并抛弃阻塞队列任务 |
| TIDYING | 010 | - | - | 任务全执行完毕，活动线程为0即将进入终结 |
| TERMINATED | 011 | - | - | 终结状态 |
这些信息存储在一个原子变量ctl中，目的是将线程状态和线程数合二为一，这样就可以用一次cas原子操作进行赋值。
// c为旧值，ctlof返回结果为新值
ctl.compareAndSet(c, ctlof(targetState, workerCountOf(c)));
// rs为高3位代表线程池状态，wc为低29位代表线程数量
private static int ctlof(int rs, int wc) { rerturn rs | wc;}
2、构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
- corePoolSize: 核心线程数
- maximumPoolSize：最大线程数
- keepAliveTime：生存时间-救急线程
- unit：时间单位-救急线程
- workQueue：阻塞队列
- threadFactory：线程工厂-创建线程
- handler：决绝策略
救急线程=最大线程数-核心线程数。用于接收执行阻塞队列满时的任务。
线程池工作过程：核心线程和救急线程都是懒惰（什么时候用什么时候创建）创建，当任务数不超过核心线程数时，线程池创建核心线程执行任务；当任务数超过核心线程数时，任务被放入阻塞队列；当前没有任务时，核心线程会从阻塞队列中获取任务执行；当阻塞队列被塞满时，线程池会创建救急线程执行任务；当任务数超过总线程数+阻塞队列时，线程池会执行决绝策略。
-
核心线程和救急线程对比：
核心线程 救急线程 创建时间 线程池初始化后开始执行任务时创建 核心线程满，阻塞队列满 生存时间 执行任务时创建，随线程池销毁 执行完任务，超过生存时间没有新任务销毁
总结：
- 线程池初始化时没有线程，当一个任务提交给线程池后，线程池才会创建线程来执行任务。
- 当线程数达到corePoolSize,这时在加入任务，新加的任务会被加入workQueue队列排队，直到有空闲的线程。
- 如果队列选择了有界队列，那么任务超过队列大小时，会创建maximumPoolSize-corePoolSize数量的线程来救急。
- 如果线程达到maximumPoolSize任然有新任务时，这时会执行拒绝策略。拒绝策略jdk提供了4中实现，其他著名框架也提供了实现：
- AbortPolicy：让调用者抛出RejectedExecutionException异常，这时默认策略。
- CallerRunsPolicy：让调用者执行任务。
- DiscardPolicy：放弃本任务。
- DiscardOldestPolicy：放弃队列中最早的任务，当前任务取而代之。
- Dubbo的实现，在抛出RejectedExecutionException异常之前会记录日志，并dump线程栈信息，方便定位问题。
- Netty的实现，是创建一个新线程来执行任务。
- ActiveMQ的实现，带超时等待尝试放入队列。
- Pinpoint的实现，它使用了一个拒绝策略链，会逐一尝试策略链中的每种拒绝策略。
- 当高峰过去，超过corePoolSize的救急线程如果过一段时间没有任务做，需要结束以节省资源，这个时间由keepAliveTime和unit来控制
根据这个构造方法，JDK Executors类中提供了众多的工厂方法来创建各种用途的线程池
3、三种常用线程池
3.1、固定大小线程池：FixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
特点
- 核心线程数=对大线程数（没有救急线程），因此无需超时时间
- 阻塞队列是无界的，可以放任意数量的任务
- 适用：适用于任务量已知，相对耗时的任务
示例：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Slf4j(topic = "c.TestFixedThreadPoolExecutor01")
public class TestFixedThreadPoolExecutor01 {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
// 自定义实现线程工厂
// ExecutorService pool = Executors.newFixedThreadPool(2, new ThreadFactory() {
// private final AtomicInteger t = new AtomicInteger(1);
//
// @Override
// public Thread newThread(Runnable r) {
// return new Thread(r, "mypool" + t.getAndIncrement());
// }
// });
pool.execute(() -> {
log.debug("1");
});
pool.execute(() -> {
log.debug("2");
});
pool.execute(() -> {
log.debug("3");
});
}
}
3.2、带缓冲的线程池：CachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUES,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
特点：
-
核心线程数0，最大线程数Integer.MAX_VALUE，救急线程空闲生成时间60s
- 全部是救急线程
- 救急线程可以无限创建
-
队列采用了SynchronousQueue，实现特点是，它没有容量，没有线程来取放不进去
import lombok.extern.slf4j.Slf4j; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit; @Slf4j(topic = "TestSynchronousQueue") public class TestSynchronousQueue { public static void main(String[] args) throws InterruptedException { SynchronousQueue<Integer> queue = new SynchronousQueue<>(); new Thread(() -> { try { log.debug("putting {}", 1); queue.put(1); log.debug("{} putted ...", 1); log.debug("putting {}", 2); queue.put(2); log.debug("{} putted ...", 2); } catch (InterruptedException e) { e.printStackTrace(); } }, "t1").start(); TimeUnit.SECONDS.sleep(1); new Thread(() -> { try { log.debug("taking {}", 1); queue.take(); } catch (InterruptedException e) { e.printStackTrace(); } }, "t2").start(); } } -
线程池线程数根据任务量不断增长，没有上限，当任务执行完毕，空闲60s后释放线程
-
适合任务比较密集，但每个任务执行时间较短的情况
3.3、单线程线程池：SingleThreadPool
public static ExecutorService newFixedThreadPool() {
return new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
适用场景：希望多个任务排队执行，线程固定数1，任务多余1时会放入无界队列。任务执行完毕，这唯一的线程也不会释放
自己创建一个线程、SingleThreadPool和 newFixedThreadPool(1)的区别：
- 自己创建一个单一线程串行执行任务，如果任务执行失败那么没有人补救措施，而线程池会创建一个新线程，保证线程池正常运行
- Executors.newSingleThreadPoll()线程数始终为1，不可被修改
- FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了ExecutorService接口，因此不能调用ThreadPoolExecutor中的特有方法
- Executors.newFixedThreadPool(1)初始线程数为1，以后可以被修改
- 对外暴露的是ThreadPoolExecutor对象，可以强转后调用setCorePoolSize等方法修改
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Slf4j(topic = "TestThreadPollExecutor01")
public class TestThreadPollExecutor02 {
public static void main(String[] args) {
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(() -> {int i = 1/0;});
pool.execute(() -> log.debug("2"));
pool.execute(() -> log.debug("3"));
}
}
4、常用方法
4.1、submit(Runnable thread)：接收Runnable接口的线程
- Future为submit返回类型，通过get方法获取线程返回值；get方法为阻塞方法
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.*;
@Slf4j(topic = "c.TestSubmit01")
public class TestSubmit01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService pool = Executors.newFixedThreadPool(2);
Future<String> future = pool.submit(() -> {
log.debug("running ...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "OK";
});
String s = future.get();
log.debug(s);
}
}
4.2、invokeAny：接收任一线程返回结果；invokeAll,接收所有线程放回的结果。
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;
@Slf4j(topic = "TestThreadPollExecutor03")
public class TestThreadPollExecutor03 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newFixedThreadPool(2);
test02(pool);
pool.shutdown();
}
public static void test02(ExecutorService pool) throws InterruptedException, ExecutionException {
String result = pool.invokeAny(Arrays.asList(
() -> {
log.debug("begin 1");
Thread.sleep(1000);
return "1";
}, () -> {
log.debug("begin 2");
Thread.sleep(500);
return "2";
}, () -> {
log.debug("begin 3");
Thread.sleep(2000);
return "3";
}
));
log.debug("result {}", result);
}
public static void test01(ExecutorService pool) throws InterruptedException {
List<Future<String>> futures = pool.invokeAll(Arrays.asList(
() -> {
log.debug("begin 1");
Thread.sleep(1000);
return "1";
}, () -> {
log.debug("begin 2");
Thread.sleep(500);
return "2";
},() -> {
log.debug("begin 3");
Thread.sleep(2000);
return "3";
}
));
futures.forEach(r -> {
try {
log.debug("get {}", r.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
});
}
}
4.3、停止
-
shutdown：把线程池状态变为SHUTDOWN
- 不会接收新任务
- 但已提交任务会执行完
- 次方法不会阻塞调用线程的执行
JDK源码：
public void shutdown() { // 加锁 final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); // 把线程池状态变为SHUTDOWN advanceRunState(SHUTDOWN); // 中断空闲线程 interruptIdleWorkers(); onShutdown(); // hook for ScheduledThreadPoolExecutor } finally { mainLock.unlock(); } // 尝试终止线程池（没有任务的线程立刻终结，如果还有执行的线程也不会等） tryTerminate(); } -
shutdownNow：线程池状态变为STOP
- 不会接收新任务
- 会将队列中的任务返回
- 并用interrupt的方式中断正在执行的任务
public List<Runnable> shutdownNow() { List<Runnable> tasks; final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(STOP); interruptWorkers(); tasks = drainQueue(); } finally { mainLock.unlock(); } tryTerminate(); return tasks; } -
其他方法
- isShutdown()：不是RUNNING状态的线程池，返回true
- isTerminated()：判断线程池状态是否TERMINATED
- awaitTermination(long timeout, TimeUnit unit)：调用shutdown后，由于调用并不会等待所有任务执行结束，因此如果它想在线程池TERMINATED后做些事情，可以利用次方法等待
源代码仓库：https://gitee.com/gaogzhen/concurrent
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
