ThreadPool线程池
线程池
- 3大方法，7大参数，4大拒绝策略
- 降低资源消耗
- 提高响应速度
- 方便管理
- 线程复用，控制最大并发数，管理线程
- 最大线程定义
- CPU密集型：几核cpu就设置为几，通过代码去获取Runtime().getRuntime().availableProcessors()
- IO密集型：判断程序中十分耗费IO的线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Demo1 {
public static void main(String[] args) {
// 单个线程
// ExecutorService threadPool = Executors.newSingleThreadExecutor();
// 可伸缩的
// ExecutorService threadPool = Executors.newCachedThreadPool();
// 固定大小
ExecutorService threadPool = Executors.newFixedThreadPool(5);
// CPU核心数
System.out.println(Runtime.getRuntime().availableProcessors() + "核");
try {
for (int i = 0; i < 10; i++) {
// 使用线程池创建线程
threadPool.execute(() -> {
System.out.println(Thread.currentThread().getName());
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭线程池
threadPool.shutdown();
}
}
}
- Executor源码
public interface Executor {
void execute(Runnable command);
}
- ExecutorService源码
public interface ExecutorService extends Executor {
void shutdown();
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
- Executors部分函数全是调用了ThreadPoolExecutors的构造函数
public static ExecutorService newSingleThreadExecutor () {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool ( int nThreads){
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool () {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
- ThreadPoolExecutor主要构造函数
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;
}
-
拒绝策略（阻塞队列满了后触发拒绝策略）
- AbortPolicy()：抛出异常
- CallerRunsPolicy()：把任务队列中的任务放在调用者线程当中运行
- DiscardPolicy() ：丢弃任务队列中最老的一个任务，也就是当前任务队列中最先被添加进去的，马上要被执行的那个任务，并尝试再次提交
- DiscardOldestPolicy()：尝试和最早的线程竞争，不会抛出异常
-
自定义线程池
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
class Demo1 {
public static void main(String[] args) {
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, // 核心线程大小
5, // 最大大小（阻塞队列满了后会启用新线程）
3, // 超时时间（超时释放的是非核心的线程）
TimeUnit.SECONDS, // 超时时间单位
new LinkedBlockingQueue<>(3), // 阻塞队列
Executors.defaultThreadFactory(), // 线程工厂
new ThreadPoolExecutor.AbortPolicy()); // 阻塞队列满了后的拒绝策略
try {
// 最大承载 = 队列 + max
for (int i = 0; i < 10; i++) {
// 使用线程池创建线程
threadPool.execute(() -> {
System.out.println(Thread.currentThread().getName());
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭线程池
threadPool.shutdown();
}
}
}
- 阻塞队列
- new LinkedBlockingQueue<>(3)：设置固定的容量，此例中：i < 5时，阻塞队列刚刚满，5个任务使用两个核心线程；i < 6时，多了一个线程，6>队列+core，此时会新开辟一个线程（总线程数不大于5），6个任务使用两个核心线程和一个新开辟的线程
- new LinkedBlockingQueue<>()：无界阻塞队列。默认容量为Integer.MAX_VALUE，核心线程都被使用后，新来的线程全都放在阻塞队列中，此时相当于设置的maximumPoolSize无效，并发数固定为corePoolSize
- new SynchronousQueue<>()：创建的线程数大于maximumPoolSize时，直接执行拒绝策略
- new ArrayBlockingQueue<>(3)：有界阻塞队列。类似new LinkedBlockingQueue<>(3)
- new PriorityBlockingQueue<>()：优先级阻塞队列
