Java多线程-线程池实现

import cn.hutool.core.date.DateUtil;
import junit.framework.TestCase;

import java.util.concurrent.*;

public class TestJug extends TestCase {

    public void testNewCachedThreadPool() throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                // 获取线程名称,默认格式:pool-1-thread-1
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                // 等待2秒
                sleep(TimeUnit.SECONDS,2);
            });
        }
        executorService.awaitTermination(3, TimeUnit.SECONDS);
    }

    public void testNewFixedThreadPool() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                // 获取线程名称,默认格式:pool-1-thread-1
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                // 等待2秒
                sleep(TimeUnit.SECONDS,2);
            });
        }
        executorService.awaitTermination(3, TimeUnit.SECONDS);

    }

    public void testNewSingleThreadPool() throws InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                // 获取线程名称,默认格式:pool-1-thread-1
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                // 等待1秒
                sleep(TimeUnit.MILLISECONDS,1000);
            });
        }
        executorService.awaitTermination(11, TimeUnit.SECONDS);

    }


    public void testNewScheduledThreadPool() throws InterruptedException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        System.out.println(DateUtil.now() + " 提交任务");
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                // 获取线程名称,默认格式:pool-1-thread-1
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                // 等待1秒
                sleep(TimeUnit.SECONDS,1);
            });
        }

        executorService.awaitTermination(6, TimeUnit.SECONDS);

    }

    public void testCreateThreadPool() throws InterruptedException {
        //阻塞队列和拒绝策略根据实际情况可自行选择
        ExecutorService executorService = new ThreadPoolExecutor(2, 10,
                1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(5, true),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                // 获取线程名称,默认格式:pool-1-thread-1
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                // 等待2秒
                sleep(TimeUnit.SECONDS,2);
            });
        }
        executorService.awaitTermination(5, TimeUnit.SECONDS);
    }

    private void sleep(TimeUnit timeUnit,int time){
        try {
            timeUnit.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Executors返回的线程池对象的弊端如下:
FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。