JUC之线程池-三大方法-七大参数-四种拒绝策略

时间:2024-08-19 21:33:20
线程池:重点 三大方法 七大参数 四种拒绝策略

使用池化技术的理由:
我们的程序伴随着创建销毁线程十分浪费资源,
所以使用线程池,先创建线程,随用随取,用完归还
简单来说就是节约了资源。

使用线程池的好处:节省资源(最大并发线程数可控);提高了响应速度;方便管理

三大方法:
1.newFixedThreadPool(线程数):创建指定数量线程的线程池
2.newSingleThreadExecutor():创建单线程的线程池
3.newCacheThreadPool():随着请求的增多线程也随之创建,遇强则强

我们之前都是用Executors创建线程池的,但是到了后期强制不可以用
因此现在用ThreadPoolExecutor创建线程池
为什么不能使用Executors创建线程池呢?
1.FixedThreadPool和SingleThreadPool允许的请求队列的长度很大,约为21亿,
所以可能堆积大量的请求,导致oom
2.CachedThreadPool允许创建的线程数量很大,可能会导致创建大量的线程,从而导致oom
代码如下:
public static void main(String[] args) {

// 三大方法之一:创建指定的线程数
ExecutorService threadPool = Executors.newFixedThreadPool(5);

//三大方法之二:创建单个线程
//ExecutorService threadPool = Executors.newSingleThreadExecutor();

//三大方法之三:随之创建,遇强则强
//ExecutorService threadPool = Executors.newCachedThreadPool();
//使用线程池创建线程
try {
for (int i = 0; i < 100; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//使用完毕,关闭线程池
threadPool.shutdown();
}
}

七大参数:
1.corePoolSize: 核心线程数,一直存活,即使线程数小于核心线程数的时候,
线程数有空闲,线程池也会创建新的线程。
2.maximumPoolSize:最大线程数,当线程数大于核心线程数的时候并且任务队列已经满了的时候,
线程池会创建新的线程,当线程数大于最大线程数的时候并且任务队列已经满了,
会抛出异常。
3.keepAliveTime: 线程空闲时间:当线程的空闲时间达到keepAliveTime时,线程会退出,
直到线程数等于核心线程数,如果allowCoreThreadTimeout=true,
则会直到线程数为0。
4.TimeUnit unit 超时时间单位。

5.BlockingQueue<Runnable> workQueue:
阻塞队列,任务队列的容量。

6.ThreadFactory threadFactory:
线程工厂,基本不用设置。
7.RejectedExecutionHandler 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.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}

四种拒绝策略:
1.new ThreadPoolExecutor..AbortPolicy():线程池满了,还有线程想加入,不处理这个请求,跑出异常
2.new ThreadPoolExecutor.CallerRunsPolicy():如果任务被拒绝,则通过调用它线程执行此任务,哪来的回哪去
3.new ThreadPoolExecutor.DiscardPolicy():队列满了,丢掉任务,不会抛出异常
4.new ThreadPoolExecutor.DiscardOldestPolicy():队列满了,尝试去和最早的竞争,不会抛出异常

IO密集型,CPU密集型:(调优)
public static void main(String[] args) {
// 自定义线程池!工作 ThreadPoolExecutor
// 最大线程到底该如何定义
// 1、CPU 密集型,几核,就是几,可以保持CPu的效率最高!
// 2、IO 密集型 > 判断你程序中十分耗IO的线程,
// 程序 15个大型任务 io十分占用资源!
// 获取CPU的核数
System.out.println(Runtime.getRuntime().availableProcessors());
ExecutorService threadPool = new ThreadPoolExecutor(
2,
Runtime.getRuntime().availableProcessors(),
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了,尝试去和
最早的竞争,也不会抛出异常!
try {
// 最大承载:Deque + max
// 超过 RejectedExecutionException
for (int i = 1; i <= 9; i++) {
// 使用了线程池之后,使用线程池来创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,关闭线程池
threadPool.shutdown();
}
}