线程池的分类

1、缓存线程池：

* 当线程执行后，由于线程池里已经有缓存的相同线程了，再创建一个新的相同的，他会调用线程池里的来运行
* (长度无限制)
* 任务加入后的执行流程
* 1、判断线程池是否存在空闲线程
* 2、存在则使用
* 3、不存在，则创建线程，并放入线程池，然后使用

package Daytime.Xianchensisuo;

import javax.lang.model.type.ExecutableType;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;



public class Demo4 {
    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();
        //向线程力加入新的任务

        service.execute(new Runnable() {
            //进程1
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });

        service.execute(new Runnable() {
            //进程2
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            //进程3
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
            try {
            Thread.sleep(100);
            } catch (Exception e) {
            e.printStackTrace();
            }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });

       

    }
}

2、定长线程池：

* （长度是指定的数值）
* 任务加入后的执行流程
* 1、判断线程池里是否存在空闲线程
* 2、存在则使用
* 3、不存在空闲线程，且线程未满的情况下，则创建线程池，然后使用
* 4、不存在空闲线程，且线程已满，则等待线程池存在空闲

package Daytime.Xianchensisuo;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo5 {
  

    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName()+"汗滴禾下土。");
                Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName()+"汗滴禾下土。");
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"汗滴禾下土。");
            }
        });
    }
}

3、单线程线程池

* 执行流程 *

1、判断线程池的那个线程空闲

2、空闲的使用

3、不空闲则等待池中的单个线程空闲后使用

package Daytime.Xianchensisuo;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo6 {
 

    
    public static void main(String[] args) {

        ExecutorService service= Executors.newSingleThreadScheduledExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午。");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午。");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午。");
            }
        });
    }
}

4、 周期任务，定长线程池

执行流程
* 1、判断线程池是否存在空闲线程
* 2、存在则使用
* 3、不存在空闲线程，且线程池未满的状态下，则创建线程，并放入线程池然后使用
* 4、不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程

package Daytime.Xianchensisuo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo7 {

    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1、定时执行一侧
         * 参数1、定时执行的任务
         * 参数2、时长数字
         * 参数3、时长数字的时间单位，TimUnit
         *

        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("锄禾日当午")；
            }
        },5, TimeUnit.SECONDS)
         */

       service.scheduleAtFixedRate(new Runnable() {
           @Override
           public void run() {
               System.out.println("锄禾日当午");
           }
       },5,1,TimeUnit.SECONDS);


    }
}