线程池的创建方式?
Executors.newCachedThreadPool(); 可缓存线程池
Executors.newFixedThreadPool(); 可定长度 限制最大线程数
Executors.newScheduledThreadPool(); 可定时
Executors.newSingleThreadExecutors(); 单例
底层都是基于ThreadPoolExecutor构造函数封装
这以上四种方式都是在我们的jdk中已经封装好了的,但是在实际项目中我们不会去使用。
因为这四种方式存在着一个很大的缺陷,因为它的底层采用的是无界队列缓存我们的任务的,
那么就有可能会发生我们的线程池溢出的情况。
代码演示:
package com.atqiyu.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author 7575
* @version 1.0
* 我亦无他,唯手熟尔!
*/
public class Test05 {
public static void main(String[] args) {
/*ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0;i < 10;i++) {
final int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+","+ finalI);
}
});
}*/
/*ExecutorService executorService = Executors.newFixedThreadPool(2);
for (int i = 0;i < 10;i++) {
final int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+","+ finalI);
}
});
}*/
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0;i < 10;i++) {
final int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+","+ finalI);
}
});
}
}
}
我们发现线程池并没有得到复用,通过阅读源码可以知道:
核心线程数:0
最大线程数:无限
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
线程池底层是如何实现复用的?
本质思想:创建一个线程,不会立马停止或者销毁而是一直实现复用。
1.提前创建固定大小的线程一直保持在运行状态;(可能会非常消耗cpu的资源)
2.当需要线程执行任务,将该任务提交缓存在并发队列中;如果缓存队列满了,则会执行拒绝策略;
3.正在运行的线程从并发队列中获取任务从而实现多线程复用问题;
线程池的核心点:复用机制 --------
1、提前创建好固定的线程一直在运行状态--------死循环实现
package com.atqiyu.threadpool;
/**
* @author 7575
* @version 1.0
* 我亦无他,唯手熟尔!
*/
public class Test04 {
public static void main(String[] args) {
new Thread(() -> {
while (true) {
System.out.println("666666");
}
}).start();
}
}
2、提交的线程任务缓存到一个并发队列集合中,交给我们正在运行的线程执行
3、正在运行的线程就从队列中获取该任务执行
java纯手写线程池:
package com.atqiyu.threadpool;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
/**
* @author 7575
* @version 1.0
* 我亦无他,唯手熟尔!
*
* 线程池核心点:复用机制 ------
* 1.提前创建好固定的线程一直在运行状态------死循环实现
* 2.提交的线程任务缓存到一个并发队列集合中,交给我们正在运行的线程执行
* 3.正在运行的线程就从队列中获取该任务执行
*/
public class MyExecutors {
private List<WorkThread> workThreads;
// 缓存我们的线程任务
private BlockingDeque<Runnable> runnableDeque;
private boolean isRun = true;
/**
* 最大线程数
* @param maxThreadCount
*/
public MyExecutors(int maxThreadCount,int dequeSize) {
//2.限制队列容量缓存大小
runnableDeque = new LinkedBlockingDeque<>(dequeSize);
//1.提前创建好固定的线程一直在运行状态------死循环实现
workThreads = new ArrayList<>(maxThreadCount);
for (int i=0;i < maxThreadCount;i++) {
// new WorkThread().start();
WorkThread workThread = new WorkThread();
workThreads.add(workThread);
workThread.start();
}
}
/**
* 工作线程
*/
class WorkThread extends Thread {
@Override
public void run() {
while (isRun||runnableDeque.size()>0) {
Runnable runnable = runnableDeque.poll();
if ( runnable != null) {
runnable.run();
}
}
}
}
/**
* 缓存线程任务
* @param command
* @return
*/
public boolean execute(Runnable command) {
return runnableDeque.offer(command);
}
public static void main(String[] args) {
MyExecutors myExecutors = new MyExecutors(2, 20);
for (int i = 0;i < 10;i++) {
int finalI = i;
myExecutors.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+ "," + finalI);
}
});
}
myExecutors.isRun = false;
}
}