Executors工厂类创建线程池的五种用法

Executors工厂类创建线程池的五种用法

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

/**
 * TODO
 *
 * @author WANDER
 * @version 1.0
 * @date 2023/10/27 13:52
 */
public class Test {

        public static void main(String[] args) {
          //  newCachedTheardPoolExample();
          //  newFixedThreadPoolExample();
         //   newSingleThreadExecutorExample();
           // newScheduledThreadPoolExample1();
            newScheduledThreadPoolExample2();
        }
    /**
     * newCachedThreadPool  会为每个任务都创建一个线程，
     * 如果有空闲线程的话也会重新使用空闲线程，
     * 如果线程没有被使用的话会在60s之后终止并从线程池中移除。
     * 它在回收旧线程时会停止创建新线程。
     * 如果存在大量长时的任务，会导致cpu占用率百分百，所以它适合任务量大但耗时少的任务
     */
   public static void newCachedTheardPoolExample(){
       ExecutorService executorService = Executors.newCachedThreadPool();
       for (int i = 0; i < 10; i++) {
           final int count = i;
           Runnable t=new Runnable(){
               @Override
               public void run() {
                   System.out.println("thread名:"+Thread.currentThread().getName());
                   System.out.println("执行任务："+count);
               }
           };
           executorService.submit(t);
       }
       //用完要关闭
       executorService.shutdown();
   }

    /**
     * newFixedThreadPool 创建了一个固定数量的线程池，
     * 它重用了固定数量的线程操作一个无界队列，
     * 无论什么时候，它最多只能运行固定数量的运行中任务，
     * 当所有线程都处于活跃状态，
     * 如果有新的任务要添加进来的话，
     * 只能在队列中等待，直到有空闲线程。
     * newFixedThreadPoll会一直运行，除非显示的调用shutdown方法。
     */
    public static void newFixedThreadPoolExample(){
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int count = i;
            Runnable t=new Runnable() {
                @Override
                public void run() {
                    System.out.println("thread名"+Thread.currentThread().getName());
                    System.out.println("执行任务："+count);
                    try {
                        Thread.sleep(3*1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            };
            executorService.submit(t);
        }
        //用完要关闭
        executorService.shutdown();
    }

    /**
     *
     * newSingleThreadExecutor 使用单个线程操作了一个无界队列创建了一个Executor，
     * 它保证了任务执行的有序性。
     * 如果向newSingleThreadExecutor中提交多个任务的话，
     * 每个任务都会保证在下个任务开始之前结束，
     *  所有的任务都将使用相同的线程
     *  多个任务顺序使用的场景
     */
    public static void newSingleThreadExecutorExample(){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int count = i;
            Runnable t=new Runnable() {
                @Override
                public void run() {
                    System.out.println("thread名"+Thread.currentThread().getName());
                    System.out.println("执行任务："+count);
                    try {
                        Thread.sleep(3*1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            };
            executorService.submit(t);
        }
        //用完要关闭
        executorService.shutdown();
    }

    /**
     * 延迟执行任务的线程池
     */
    public static void newScheduledThreadPoolExample1(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int count = i;
            Runnable t=new Runnable() {
                @Override
                public void run() {
                    System.out.println("thread名"+Thread.currentThread().getName()+"执行任务："+count);
                    try {
                        Thread.sleep(1 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            executorService.schedule(t,3 , TimeUnit.SECONDS);
        }
        System.out.println("------------");
        //用完要关闭
        executorService.shutdown();
    }

    /**
     * 周期性执行任务的线程池
     */
    public static void newScheduledThreadPoolExample2(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int count = i;
            Runnable t=new Runnable() {
                @Override
                public void run() {
                    System.out.println("thread名"+Thread.currentThread().getName()+"执行任务："+count);
                    try {
                        Thread.sleep(1 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            executorService.scheduleAtFixedRate(t, 1,20 , TimeUnit.SECONDS);
        }
        //用完要关闭
      //  executorService.shutdown();
    }
}