目录 1.什么是线程池？ 2 线程池创建种类 2.1通过线程池代码创建线程 2.1.Executors创建的线程池 2.1.1 newFixedThreadPool重用固定数量线程的线程池
目录
- 1.什么是线程池？
- 2 线程池创建种类
- 2.1通过线程池代码创建线程
- 2.1.Executors创建的线程池
- 2.1.1 newFixedThreadPool重用固定数量线程的线程池
- 2.1.2 newWorkStealingPool(int parallelism)抢占式执行的线程池
- 2.1.3 newSingleThreadExecutor()单例的线程池
- 2.1.4 newCachedThreadPool()可缓存的线程池
- 2.1.5 newSingleThreadScheduledExecutor()单线程的可以执行延迟任务的线程池
- 2.1.6 newScheduledThreadPool(int corePoolSize)周期性的运行任务线程池
1.什么是线程池？
2 线程池创建种类
2.1通过线程池代码创建线程
public void two() throws Exception{Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int count=0;
for (int i = 0; i < 5; i++) {
Thread.sleep(1200);
count++;
}
return count;
}
};
ExecutorService e= Executors.newFixedThreadPool(10);
Future<Integer> f1=e.submit(callable);
Integer result = f1.get();
System.out.println("获取多线程的值:"+result);
}
通过上述代码，我们可以知道实现线程池涉及到ExecutorService和Executors。下面我们来一个个进行源码分析
2.1.Executors创建的线程池
在idea中，把光标放到Executors上，按住鼠标左键+ctrl进入Executors类。输入alt+7查看该类下的所有方法。
2.1.1 newFixedThreadPool重用固定数量线程的线程池
创建一个重用固定数量线程的线程池，如果在所有线程都处于活动状态时提交了额外的任务，他们将在队列中等待，直到线程可用为止。
public class FixedThreadPoolDemo {public static void main(String[] args) {
// 创建 2 个线程的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
// 创建任务
Runnable runnable = () -> System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
// 线程池执行任务(一次添加 8 个任务)
threadPool.execute(runnable);
threadPool.execute(runnable);
threadPool.execute(runnable);
threadPool.execute(runnable);
threadPool.execute(runnable);
threadPool.execute(runnable);
threadPool.execute(runnable);
threadPool.execute(runnable);
}
}
2.1.2 newWorkStealingPool(int parallelism)抢占式执行的线程池
jdk1.8后引入的，它是新的线程池类ForkJoinPool的扩展，能够合理的使用CPU,进行并发运行任务。
创建一个线程池，维护足够的线程以支持给定的并行度级别，并且可以使用多个队列来减少争用
// 并行度级别对应于主动参与或可用于参与任务处理的最大线程数。
// 线程的实际数量可能会动态增长和收缩。
// 工作窃取池不保证提交任务的执行顺序。
// 并行度——目标并行度级别
//一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行。
ExecutorService forkJoin = Executors.newWorkStealingPool();
forkJoin.execute(new Runnable() {
@Override
public void run() {
System.out.println("i====>" + 1);
}
});
forkJoin.execute(new Runnable() {
@Override
public void run() {
System.out.println("i====>" + 2);
}
});
forkJoin.execute(new Runnable() {
@Override
public void run() {
System.out.println("i====>" + 3);
}
});
forkJoin.execute(new Runnable() {
@Override
public void run() {
System.out.println("i====>" + 4);
}
});
forkJoin.shutdown();
2.1.3 newSingleThreadExecutor()单例的线程池
创建一个单例的线程池，也就是说池中就一个线程。通过这个线程来处理所有的任务，如果发现这个这个线程因为失败而关闭，不要慌，会有一个线程来取代他，保证任务能正常的运转
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
public class NewSingleThreadExecutor {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index=i;
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(index == 5){ //故意搞破坏
int flag =index/0;
}
System.out.println(Thread.currentThread().getName());
}
});
}
}
}
2.1.4 newCachedThreadPool()可缓存的线程池
创建一个可缓存的线程池，若线程数超过所需，那么多余的线程会被缓存一段时间后再回收，若线程数不够，则会新建线程。
public class CachedThreadPoolDemo {public static void main(String[] args) {
// 创建线程池
ExecutorService threadPool = Executors.newCachedThreadPool();
// 执行任务
for (int i = 0; i < 5; i++) {
threadPool.execute(() -> {
System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
});
}
}
}
2.1.5 newSingleThreadScheduledExecutor()单线程的可以执行延迟任务的线程池
创建一个单线程的可以执行延迟任务的线程池。这种线程池可以看做是 ScheduledThreadPool 的单线程版本。
public class SingleThreadScheduledExecutorDemo {public static void main(String[] args) {
// 创建线程池
ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
// 添加定时执行任务(2s 后执行)
System.out.println("添加任务,时间:" + new Date());
threadPool.schedule(() -> {
System.out.println("任务被执行,时间:" + new Date());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
}, 2, TimeUnit.SECONDS);
}
}
2.1.6 newScheduledThreadPool(int corePoolSize)周期性的运行任务线程池
此线程池的的线程可以定时周期性的运行任务。注意坑点：使用这种方法，如果出现异常，会导致无法正常的运行任务。所以，个人建议，使用这种方式的时候，run方法里面的代码可以加上异常处理逻辑。这种方式newSingleThreadExecutor类似，只是增加了周期性运行，这里不过多的阐述。
public static void main(String[] args) {
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("开始时间："+Thread.currentThread().getName()+","+new Date());
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},2000,6000,TimeUnit.MILLISECONDS);
}
}
通过截图我们可以发现是6秒一次。
保证period>initialDelay，以period为准。以period的时长为一个周期
如果run方法运行时间大于period，定时任务的周期以run运行时长为一个周期。
