线程池：三大方法、7大参数、4种拒绝策略
池化技术
程序的运行，本质：占用系统的资源！我们需要去优化资源的使用 ===> 池化技术
线程池、JDBC的连接池、内存池、对象池 等等。。。。
资源的创建、销毁十分消耗资源
池化技术：事先准备好一些资源，如果有人要用，就来我这里拿，用完之后还给我，以此来提高效率。
线程池的好处：
1、降低资源的消耗；
2、提高响应的速度；
3、方便管理；
线程复用、可以控制最大并发数、管理线程；
线程池：三大方法
ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的
//工具类 Executors 三大方法；
public class Demo01 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的
//线程池用完必须要关闭线程池
try {
for (int i = 1; i <=100 ; i++) {
//通过线程池创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+ " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
7大参数
源码分析
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;
}
阿里巴巴的Java操作手册中明确说明：对于Integer.MAX_VALUE初始值较大，所以一般情况我们要使用底层的ThreadPoolExecutor来创建线程池。
业务图
手动创建线程池
package com.can.pool;
import java.util.concurrent.*;
//Executors不安全，所以要自定义new ThreadPoolExecutor
//自定义线程池
//new ThreadPoolExecutor.AbortPolicy()); //队列满了，还有人进来，不处理这个人的，抛出异常
//new ThreadPoolExecutor.DiscardPolicy()); //队列满了，还有人进来，不处理这个人的，不会抛出异常
// new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了，尝试去和最早的竞争，不会抛出异常
//new ThreadPoolExecutor.CallerRunsPolicy()); //队列满了，哪来的去哪里！打发 这里是main线程去处理
public class Executors02 {
public static void main(String[] args) {
//- corePoolSize：核心线程池大小
//- maximumPoolSize：最大核心线程池大小
//- keepAliveTime：最大线程池的大小,超时了没有人调用就会释放
//- unit：超时单位
//- workQueue：阻塞队列,等候区满了，使用最大线程池
//- threadFactory：线程工程，创建线程的，一般不用动
//- handler：拒绝策略
ExecutorService threadPool = new ThreadPoolExecutor(
2,
5,
3,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了，尝试去和最早的线程竞争，不会抛出异常
try {
//最大承载：Queue + max
//超过 RejectedExecutionException
for (int i = 0; i < 9; i++) {
//使用了线程池之后，要使用线程池来创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" OK");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完，程序结束，关闭线程池
threadPool.shutdown();
}
}
}
拒绝策略4种
（1）new ThreadPoolExecutor.AbortPolicy()： //该拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常
超出最大承载，就会抛出异常：队列容量大小+maxPoolSize
2）new ThreadPoolExecutor.CallerRunsPolicy()： //该拒绝策略为：哪来的去哪里 main线程进行处理
（3）new ThreadPoolExecutor.DiscardPolicy(): //该拒绝策略为：队列满了,丢掉异常，不会抛出异常。
（4）new ThreadPoolExecutor.DiscardOldestPolicy()： //该拒绝策略为：队列满了，尝试去和最早的进程竞争，不会抛出异常
小结和拓展
如何去设置线程池的最大大小如何去设置？
CPU密集型和IO密集型！
1、CPU密集型：电脑的核数是几核就选择几；选择maximunPoolSize的大小
我们可以使用代码来来获取逻辑处理器数量。
于是cpu密集型的写法如下：
2、I/O密集型：
在程序中有15个大型任务，io十分占用资源；I/O密集型就是判断我们程序中十分耗I/O的线程数量，大约是最大I/O数的一倍到两倍之间。
四大函数式接口（必需掌握）
新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口：只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//超级多的@FunctionalInterface
//简化编程模型，在新版本的框架底层大量应用
//foreach()的参数也是一个函数式接口，消费者类的函数式接口
函数型接口可以使用lambda表达式；
代码测试：
Function函数型接口
/**
* Function函数型接口
*/
public class Demo01 {
public static void main(String[] args) {
Function<String,String> function = (str) ->{return str;};
System.out.println(function.apply("starasdas"));
}
}
Predicate断定型接口
/**
* 断定型接口：有一个输入参数，返回值只能是 布尔值！
*/
public class Demo2 {
public static void main(String[] args) {
//判断字符串是否为空
Predicate<String> predicate = (str)->{return str.isEmpty();};
System.out.println(predicate.test("11"));
System.out.println(predicate.test(""));
}
}
Consummer 消费型接口
/**
* 消费型接口 没有返回值！只有输入！
*/
public class Demo3 {
public static void main(String[] args) {
Consumer<String> consumer = (str)->{
System.out.println(str);
};
consumer.accept("abc");
}
}
Supplier供给型接口
/**
* 供给型接口，只返回，不输入
*/
public class Demo4 {
public static void main(String[] args) {
Supplier<String> supplier = ()->{return "1024";};
System.out.println(supplier.get());
}
}