java之线程池
线程池：三大方法、七大参数、四种拒绝策略
池化技术
程序的运行，本质：占用系统的资源！优化资源的使用！=> 池化技术
线程池、连接池、内存池、对象池///… 创建、销毁十分浪费资源
池化技术： 事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我
线程池的好处：
1、降低资源的消耗
2、提高相应的速度
3、方便管理
线程复用、可以控制最大并发数、管理线程
线程池：三大方法
ExecutorService threadExecutor = Executors.newSingleThreadExecutor();// 单个线程
Executors.newFixedThreadPool(5); // 固定大小的线程池
ExecutorService threadExecutor = Executors.newCachedThreadPool(); // 可伸缩的线程池
//Executors 工具类 3大方法
//使用了线程池之后要使用线程池创建线程
public class Demo01 {
public static void main(String[] args) {
// ExecutorService service = Executors.newSingleThreadExecutor();//单个线程
// ExecutorService service = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
ExecutorService service = Executors.newCachedThreadPool();//可伸缩的，
try {
for (int i = 0; i < 10; i++) {
service.execute(() -> {
System.out.println(Thread.currentThread().getName() + "ok");
});
}
//线程池用完要关闭线程池
} finally {
service.shutdown();
}
}
}
线程池：七大参数
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
手动创建线程池
public class testThreadPoolExecutor {
public static void main(String[] args) {
ExecutorService threadPoolExecutor = new ThreadPoolExecutor(
2,//核心线程数
4,//最大线程数
3,//多久没调用就释放池
TimeUnit.SECONDS,//超时单位
new ArrayBlockingQueue<>(6),//阻塞队列大小
Executors.defaultThreadFactory(), // 线程工厂，创建线程的，默认不用改
//队列满了，线程池满了，还有其他任务过来时拒绝策略
// new ThreadPoolExecutor.AbortPolicy()//满了，不处理，抛出异常
// new ThreadPoolExecutor.CallerRunsPolicy()//由调用线程（提交任务的线程）处理该任务
// new ThreadPoolExecutor.DiscardPolicy()//满了，丢掉任务，不抛出异常
new ThreadPoolExecutor.DiscardOldestPolicy()//抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
);
try {
// 最大承载：Deque + max 等待队列容量和最大线程数之和
// 超过 RejectedExecutionException 抛不抛出异常看拒绝策略
for (int i = 0; i <12; i++) {
// 使用了线程池之后，使用线程池来创建线程
threadPoolExecutor.execute(() -> {
System.out.println(Thread.currentThread().getName() + "run");
});
}
} catch (Exception exception) {
exception.printStackTrace();
} finally {
// 线程池用完，程序结束，关闭线程池
threadPoolExecutor.shutdown();
}
}
}线程池：四种拒绝策略
/*
* new ThreadPoolExecutor.AbortPolicy() // 银行满了 还有人进来，不处理这个人，抛出异常
* new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里，下面的线程就是main执行了多出来的一个人
* new ThreadPoolExecutor.DiscardPolicy() // 不抛出异常，银行满了，丢点任务
* new ThreadPoolExecutor.DiscardOldestPolicy() // 银行满了，试探最早的是否结束，如果结束就跟进，没结束就不处理，不抛出异常。不是插队
* */
public class Demo02 {
public static void main(String[] args) {
ExecutorService threadPool = new ThreadPoolExecutor(
2,
5,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
// new ThreadPoolExecutor.AbortPolicy() // 银行满了 还有人进来，不处理这个人，抛出异常
// new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里，下面的线程就是main执行了多出来的一个人
// new ThreadPoolExecutor.DiscardPolicy() // 不抛出异常，银行满了，丢点任务
new ThreadPoolExecutor.DiscardOldestPolicy() // 银行满了，试探最早的是否结束，如果结束就跟进，没结束就不处理，不抛出异常。不是插队
);
try {
// 最大承载 que + 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();
}
}
}
小结和扩展
最大线程如何定义
1、CPU密集型 几核，就是几，可以保持CPU的效率最高 线程 CPU密集型是
System.out.println(Runtime.getRuntime().availableProcessors()); 输出核数量
2、IO密集型 > 判断程序中十分耗IO的线程 一般两倍
程序 1个大型任务 io十分占内存
public class Demo03 {
public static void main(String[] args) {
// 最大线程到底该如何定义
// 1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！
// 2、IO 密集型 > 判断你程序中十分耗IO的线程，
// 程序 15个大型任务 io十分占用资源！
// 获取CPU的核数
System.out.println(Runtime.getRuntime().availableProcessors());
// 自定义线程池！工作 ThreadPoolExecutor
ExecutorService threadPoolExecutor = 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++) {
// 使用了线程池之后，使用线程池来创建线程
threadPoolExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完，程序结束，关闭线程池
threadPoolExecutor.shutdown();
}
}
}
