线程池使用之自定义线程池

 构造方法:

    
 public ThreadPoolExecutor(int corePoolSize, //核心线程数量
    
                           int maximumPoolSize,//     最大线程数
    
                           long keepAliveTime, //       最大空闲时间
    
                           TimeUnit unit,         //        时间单位
    
                           BlockingQueue<Runnable> workQueue,   //   任务队列
    
                           ThreadFactory threadFactory,    // 线程工厂
    
                           RejectedExecutionHandler handler  //  饱和处理机制
    
 	) 
    
 { ... }

 /*

    
     需求:
    
     自定义线程池练习,这是任务类,需要实现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) {
    
     super(name);
    
     this.tasks = tasks;
    
     }
    
  
    
     @Override
    
     public void run() {
    
    //判断集合中是否有任务,只要有,就一直执行任务
    
     while (tasks.size()>0){
    
         Runnable r = tasks.remove(0);
    
         r.run();
    
     }
    
     }
    
 }

 /*

    
     这是自定义的线程池类;
    
   4.     成员变量:
    
     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;
    
     }
    
  
    
     //1:提交任务;
    
     public void submit(Runnable r){
    
     //判断当前集合中任务的数量,是否超出了最大任务数量
    
     if(tasks.size()>=workSize){
    
         System.out.println("任务:"+r+"被丢弃了...");
    
     }else {
    
         tasks.add(r);
    
         //执行任务
    
         execTask(r);
    
     }
    
     }
    
     //2:执行任务;
    
     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) {
    
     //1:创建线程池类对象;
    
     MyThreadPool pool = new MyThreadPool(2,4,20);
    
     //2: 提交多个任务
    
     for (int i = 0; i <30 ; i++) {
    
         //3:创建任务对象,并提交给线程池
    
         MyTask my = new MyTask(i);
    
         pool.submit(my);
    
     }
    
     }
    
 }