思想：
一种多线程处理的形式，处理过程中可以将任务添加到队列中。
优势：
1.线程与任务分离，提升线程重用性；
2.控制线程并发数量，降低服务器压力，统一管理
3.提升系统相应速度
思路：
1.需要一个任务类MyTask，实现Runnale接口,处理业务；
2.需要一个线程类MyWork，继承Thread类；
3.自定义的线程池类MyThreadPool，统一管理线程与任务；
代码：
/**
* 需求：
* 自定义线程池练习，这是任务类，需要实现Runnable；
* 包含任务编号，每一个任务执行时间设计为0.2秒
*/
public class Mytask implements Runnable {
private int id;
//由于run方法是重写接口中的方法，因此id这个属性初始化可以利用构造方法完成
public Mytask(int id){
this.id = id;
}
@Override
public void run() {
String name = Thread.currentThread().getName();
System.out.println("线程："+name+"即将执行任务："+id);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程："+name+"完成了任务："+id);
}
@Override
public String toString(){
return "MyTask{"+"id="+id+"}";
}
}
/**
* 需求：
* 编写一个线程类，需要继承Thread类。设计一属性，用于保存线程的名字；
* 设计一个集合，用于保存所有的任务；
*/
public class MyWorker extends Thread{
private String name;
private List<Runnable> tasks;
//利用构造方法，给成员变量赋值
public MyWorker(String name, List<Runnable> tasks){
this.name= name;
this.tasks = tasks;
}
@Override
public void run(){
//判断集合中是否有任务，只要有，就一直执行任务
while(tasks.size()>0){
Runnable remove = tasks.remove(0);
remove.run();
}
}
}
/**
* 这是自定义的线程池类；
* 成员变量：
* 1：任务队列 集合 需要控制线程安全问题
* 2：当前线程数量
* 3：核心线程数量
* 4：最大线程数量
* 5：任务队列的长度
* 成员方法：
* 1：提交任务：将任务添加到集合中，需要判断是否超出了任务总长度
* 2：执行任务：判断当前线程的数量，决定创建核心线程还是非核心线程
*
*/
public class MyThreadPool {
//1：任务队列 集合 需要控制线程安全问题
private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
//2：当前线程数量
private int num;
//3：核心线程数量
private int corePoolSize;
//4：最大线程数量
private int maxSize;
//5：任务队列的长度
private int workSize;
public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
this.corePoolSize = corePoolSize;
this.maxSize = maxSize;
this.workSize = workSize;
}
public void submit(Runnable r){
//判断当前集合中任务的数量，是否超出了最大任务数量
if(tasks.size() >= workSize){
System.out.println("任务："+r+"被丢弃了。。。");
}else {
tasks.add(r);
//执行任务
execTask(r);
}
}
private void execTask(Runnable r) {
//判断当前线程池中的线程总数量是否超出了核心数
if(num < corePoolSize){
new MyWorker("核心线程："+num,tasks).start();
num++;
}else if(num < maxSize){
new MyWorker("非核心线程："+num,tasks).start();
num++;
}else {
System.out.println("任务："+r+"被缓存了。。。");
}
}
}
测试：
/**
* 测试类
* 1：创建线程池类对象
* 2：提交多个任务
*/
public class MyTest {
public static void main(String[] args) {
MyThreadPool myThreadPool = new MyThreadPool(2, 4, 20);
for (int i = 0; i <10 ; i++) {
Mytask mytask = new Mytask(i);
myThreadPool.submit(mytask);
}
}
}
结果：
image.png
