为什么要使用线程池
- 减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存
使用newFixedThreadPool线程池
newFixedThreadPool 将创建一个固定长度的线程池
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class test0 {
public static void main(String[] args){
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 4; i++){
Runnable runnable = new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行");
}
};
executor.execute(runnable);
}
executor.shutdown();
}
}
pool-1-thread-1正在执行
pool-1-thread-2正在执行
pool-1-thread-3正在执行
pool-1-thread-3正在执行
使用newCachedThreadPool线程池
newCachedThreadPool 将创建一个可缓存的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class test0 {
public static void main(String[] args){
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < 4; i++){
Runnable runnable = new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行");
}
};
executor.execute(runnable);
}
executor.shutdown();
}
}
pool-1-thread-1正在执行
pool-1-thread-3正在执行
pool-1-thread-2正在执行
pool-1-thread-4正在执行
使用newSingleThreadExecutor线程池
newSingleThreadExecutor 能确保依照任务在队列中的顺序来串行执行
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class test0 {
public static void main(String[] args){
ExecutorService executor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 4; i++){
Runnable runnable = new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行");
}
};
executor.execute(runnable);
}
executor.shutdown();
}
}
pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行
使用newScheduledThreadPool线程池
newScheduledThreadPool 创建了一个固定长度的线程池,而且以延迟或定时或周期的方式来执行任务,类似于 Timer、定时任务。可应用于重发机制。此代码会无限循环输出。
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class test0 {
public static void main(String[] args){
ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
for (int i = 0; i < 2; i++){
final int index = i;
Runnable runnable = new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "延时 1s 后,每 2s 执行一次工作任务--- >" + index);
}
};
executor.scheduleAtFixedRate(runnable,1,2,TimeUnit.SECONDS);
}
if (executor.isShutdown()) {
executor.shutdown();
}
}
}
pool-1-thread-1延时 1s 后,每 2s 执行一次工作任务— >0
pool-1-thread-2延时 1s 后,每 2s 执行一次工作任务— >1
pool-1-thread-2延时 1s 后,每 2s 执行一次工作任务— >0
pool-1-thread-1延时 1s 后,每 2s 执行一次工作任务— >1
pool-1-thread-3延时 1s 后,每 2s 执行一次工作任务— >0
pool-1-thread-2延时 1s 后,每 2s 执行一次工作任务— >1
pool-1-thread-1延时 1s 后,每 2s 执行一次工作任务— >0
pool-1-thread-3延时 1s 后,每 2s 执行一次工作任务— >1
pool-1-thread-2延时 1s 后,每 2s 执行一次工作任务— >0
… …
常用的使用方法是调用 Executors 中的静态方法来创建一个连接池。java 自带的线程池仅有 4 种:
- newFixedThreadPool
- newCachedThreadPool
- newSingleThreadExecutor
- newScheduledThreadPool
以上四种创建线程池的方法其实都是调用java.util.concurrent.ThreadPoolExecutor 的构造函数,只是参数不一样:
- corePoolSize : 核心线程数
- maximumPoolSize : 最大线程数
- keepAliveTime : 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间
- unit : 时间单位
- workQueue : 用于存储工作工人的队列
- threadFactory : 创建线程的工厂
- handler : 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序
常用的几种队列
- ArrayBlockingQueue:规定大小的 BlockingQueue , 其构造必须指定大小。其所含的对象是 FIFO 顺序排序的。
- LinkedBlockingQueue : 大小不固定的 BlockingQueue , 若其构造时指定大小,生成的 BlockingQueue 有大小限制,不指定大小,其大小有 Integer.MAX_VALUE 来决定。其所含的对象是 FIFO 顺序排序的。
- PriorityBlockingQueue :类似于 LinkedBlockingQueue , 但是其所含对象的排序不是 FIFO,而是依据对象的自然顺序或者构造函数的 Comparator 决定。
- SynchronizedQueue:特殊的 BlockingQueue,对其的操作必须是放和取交替完成。
排队策略
-
直接提交。工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
-
无界队列。使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样,创建的线程就不会超过 corePoolSize。(因此,maximumPoolSize 的值也就无效了。)当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web 页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
-
有界队列。当使用有限的 maximumPoolSizes 时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O 边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU 使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量。