通过Executors创建线程池的四种方式和注意小点

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的读者更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

1）FixedThreadPool 和 SingleThreadPool:

允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

2）CachedThreadPool 和 ScheduledThreadPool:

允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
}

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

public class ThreadRunnable implements Runnable {
    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + ">>>>>>>CurrentTime:" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class NewCachedThreadPool {
    public static void main(String[] args) {
        //线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
        ExecutorService pool = Executors.newCachedThreadPool();
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) pool;
        for (int i = 0; i ) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            threadPoolExecutor.execute(new ThreadRunnable());
//            threadPoolExecutor.execute(() -> {
//                System.out.println(Thread.currentThread().getName() + ">>>>>>>CurrentTime:" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
//                 try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            });
        }
        threadPoolExecutor.shutdown();
    }
}

public class NewFixedThreadPool {
    public static void main(String[] args) {
        //线程池数量指定为2代表就创建两个线程，无论多少消息就用两条线程去处理，
        // 如果线程数量为1，类似单线程执行方法
        //创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
//        ExecutorService pool = Executors.newFixedThreadPool(1);
        ExecutorService pool = Executors.newFixedThreadPool(2);
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) pool;
        for (int i = 0; i ) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            threadPoolExecutor.execute(new ThreadRunnable());
        }
        threadPoolExecutor.shutdown();
    }
}

public class NewScheduledThreadPool {
    //创建一个定长线程池，支持定时及周期性任务执行
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程："+Thread.currentThread().getName()+">>>延迟1秒后每3秒执行一次,时间是："+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss")));
            }
        }, 1000, 3000, TimeUnit.MILLISECONDS);
//        不能有关闭方法，否则线程池关闭就无法持久输出了
//        scheduledExecutorService.shutdown();
    }
}

public class NewSingleThreadExecutor {
    static int a = 0;
    //创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i             try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            pool.execute(() -> {
                ++a;
                System.out.println(Thread.currentThread().getName() + "顺序打印了" + a);
            });
        }
        pool.shutdown();
    }
}

class test4 implements Callable{

    @Override
    public Object call() throws Exception {
        //System.out.println("科技");
        return "1";
    }
}

class test5{
    static int a = 0;
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        ArrayList> list = new ArrayList();
        for (int i = 0; i ) {
//            pool.submit(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println("我打印了"+ (a++));
//                }
//            });
            Future submit = pool.submit(new test4());
            list.add(submit);
        }
        pool.shutdown();
        System.out.println(list.size());
        // 遍历任务的结果
        for (Future fs : list) {
            try {
                System.out.println(fs.get()); // 打印各个线程（任务）执行的结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}