Executors.newFixedThreadPool(int threads)和Executors.newCachedThreadPool()

        newFixedThreadPool和newCachedThreadPool是创建线程池的两种方式，其中newFixedThreadPool是创建固定数量为 threads的线程数，其阻塞队列用的是LinkedBlockingQueue，队列大小容量为Integer.MAX_VALUE;newCachedThreadPool是创建一个可缓存的线程池，不会对线程池的大小做任何的限制，其大小是依赖于操作系统能够创建的最大线程大小。

缺点：

newFixedThreadPool：阻塞队列容量大，当队列中推积的数据过多会造成CPU内存过高异常，导致程序异常退出。

newCachedThreadPool：线程池大小没有做限制，当任务来了直接创建线程，易导致资源消耗殆尽。

newCachedThreadPool适合执行时间比较小的任务，因为newCachedThreadPool线程池的大小超过了要处理任务的数量，空闲线程超过60s,那么空闲线程就会被回收，即能够复用空闲线程，减少创建对象和回收对象带来的开销。不同于newFixedThreadPool，newFixedThreadPool是创建固定容量大小的线程池，也就是即使空闲时间超过一定时间，也不会回收空闲线程，始终占用着cpu资源，但是其优点在于能够控制住最大并发数。

package com.glch.threads;

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

/**
 * @author zzl
 * @Date 2021/9/15
 * @description 创建一个固定数量的线程池
 */
public class FixThreadPool {
    private static ExecutorService executorService = null;

    public static ExecutorService getInstance() {
        if (executorService == null) {
            executorService = Executors.newFixedThreadPool(3);
        }
        return executorService;
    }
}



package com.glch.threads;

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

/**
 * @author zzl
 * @Date 2021/9/15
 * @description 创建一个可以缓存的线程池
 */
public class CacheThreadPool {
    private static ExecutorService executorService;

    public static ExecutorService getInstance(){
        if(executorService==null){
            executorService = Executors.newCachedThreadPool();
        }
        return executorService;
    }
}


package com.glch.threads;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

/**
 * @author zzl
 * @Date 2021/9/15
 * @description
 */
public class FixThreadPoolTest {
    public static void main(String[] args) {
        // 测试newFixThreadPool
        ExecutorService pool = FixThreadPool.getInstance();
        // execute的方式，这种方式无法从线程池中返回结果集，即没有返回值
        for (int i = 0; i < 4; i++) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("666");
                    try {
                        Thread.sleep(6000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        for (int i = 0; i < 4; i++) {
            pool.execute(new Thread(() -> {
                System.out.println("666");
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }));
        }
        // summit的方式，有返回值，且方便做异常处理，Future.get()可捕获异常
        for (int i = 0; i < 4; i++) {
            Future future = pool.submit(new Thread(() -> {
                System.out.println("666");
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }));
        }

    }
}