java基础4–池化技术
三大类型
源码分析:
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,//21亿
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
七大参数
七大参数
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;
}
- 单个线程
- 创建一个固定大小的线程池
- 可伸缩创建线程池
import java.util.concurrent.*;
public class TestExe {
public static void main(String[] args) {
//单个线程执行
ExecutorService threadPool= Executors.newSingleThreadExecutor();
//创建一个固定大小的线程池
ExecutorService threadPool1= Executors.newFixedThreadPool(6);
//可伸缩创建大小
ExecutorService threadPool2=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.shutdownNow();
}
System.out.println("=====================");
try {
for (int i = 0; i < 100; i++) {
threadPool1.execute(()->{
System.out.println(Thread.currentThread().getName()+"结束!");
}); }
}finally {
threadPool1.shutdownNow();
}
System.out.println("=====================");
try {
for (int i = 0; i < 100; i++) {
threadPool2.execute(()->{
System.out.println(Thread.currentThread().getName()+"线程创建完成!");
}); }
}finally {
threadPool2.shutdownNow();
}
}
}
四大策略
四大策略处理
import java.util.concurrent.*;
public class Test02 {
public static void main(String[] args) {
ExecutorService threadPoll=new ThreadPoolExecutor(2,5,3,
TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());//超过最大线程数,就抛出异常
try {
for (int i = 0; i < 8; i++) {
threadPoll.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPoll.shutdownNow();
}
ExecutorService threadPoll1=new ThreadPoolExecutor(2,5,3,
TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());//哪来的去哪里
try {
for (int i = 0; i < 10; i++) {
threadPoll1.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok1111111111");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPoll1.shutdownNow();
}
ExecutorService threadPoll2=new ThreadPoolExecutor(2,5,3,
TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardPolicy());//队列满了,丢掉任务,不会抛出异常!
try {
for (int i = 0; i < 10; i++) {
threadPoll2.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok2222222222222222222");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPoll2.shutdownNow();
}
ExecutorService threadPoll3=new ThreadPoolExecutor(2,5,3,
TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy());//队列满了,尝试去和最早的竞争,也不会抛出异常!
try {
for (int i = 0; i < 10; i++) {
threadPoll3.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok333333333333333333333333333");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPoll3.shutdownNow();
}
}
}
小结和拓展
-
CPU密集型
找到最大的处理器核数
Runnable.getRuntime().availableProcessors();
-
IO密集型
判断程序中十分耗io的线程,一般大于两倍的数量。