JAVA线程池核心知识点详解

核心线程数量corePoolSize

核心线程数的设计:
  根据任务的处理时间和每秒产生的任务数量来确定

例
  执行一个任务需要0.1秒,系统百分之八十的时间没秒都会产生100个任务
  那么我们想要在1秒内处理完这100个任务,就需要10个线程
  此时我们就可以设计核心线程数量为10,
  当时实际情况不可能这么平均,
   所以一般我们按照2080原则设计即可
   即按照百分之80的情况设计核心线程数量
   剩下的百分之20可以利用最大线程数量处理

任务队列长度(workQueue)

任务队列长度:
   一般设计为核心线程数/单个任务执行时间*2(任务最大等待时间/s)即可

例:
  上面场景中,核心线程数设计为10
  单个任务执行时间为0.1,则队列长度可以设计为200

最大线程数(maximumPoolSize)

最大线程数的设计:
   除需要参照核心线程数的条件外,
   还需要参照系统每秒产生的最大任务数决定

例:
 如果系统每秒最大产生的任务数量是1000个
 那么最大线程数=(最大任务数-任务队列长度)* 单个任务执行时间
 即:最大线程数=(1000-200)* 0.1 =80;
 当然最大线程数和服务器的硬件配置也有很大关系

定义线程池

模拟任务类

package com.java265;
 
public class MyTask implements Runnable {
    private  int 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 +
                '}';
    }
}

自定义线程类

package com.java265;
 
import java.util.Arraylist;
import java.util.List;
public class MyWorker extends Thread {
 
    private String name;
 
    private List<Runnable> tasks = new ArrayList<>();
 
    public MyWorker(String name, List<Runnable> tasks) {
        super(name);
        this.tasks = tasks;
    }
 
    @Override
    public void run() {
        while (tasks.size() > 0) {
            Runnable r = tasks.remove(0);
            r.run();
        }
    }
}

自定义线程池类

package com.java265;
 
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class MyThreadPool {
 
 
    /**
     * 任务集合 多个线程同时remove 
     */
    private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
    /**
     * 当前先测试数量
     */
    private int num;
    /**
     * 核心线程数量
     */
    private int coreThreadSize;
    /**
     * 最大线程数量
     */
    private int maxThreadSize;
 
    /**
     * 队列长度
     */
    private int workSize;
 
    public MyThreadPool( int coreThreadSize, int maxThreadSize, int workSize) {
        this.coreThreadSize = coreThreadSize;
        this.maxThreadSize = maxThreadSize;
        this.workSize = workSize;
    }
  
    public void submitTask(Runnable r) {
        if (tasks.size() >= workSize) {
            System.out.println("任务" + r + "丢掉了");
        } else {
            //加入队列
            tasks.add(r);
            //执行队列
            execTask(r);
        }
    }
 
    private void execTask(Runnable r) {
        //判断是否需要创建核心线程池
        if (num < coreThreadSize) {
            //创建核心线程池执行
            new MyWorker("核心线程池" + num, tasks).start();
            num++;
        } else if (num < maxThreadSize) {
            //创建非核心线程池执行
            new MyWorker("非核心线程池" + num, tasks).start();
            num++;
        } else {
            System.out.println("任务" + r + "被缓存了");
        }
    }
}

测试类

package com.java265;
 
public class MyTask implements Runnable {
    private  int 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 +
                '}';
    }
}