【多线程】如何创建线程池

ThreadPoolExecutor构造方法创建线程池

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 线程池创建
 * @author zmxqq
 * @date 2020/12/1 - 18:59
 */
public class test2 {
    /**
     * 实现Runnable的任务类，对象作为参数传给Thread构造方法。
     */
    static class Task implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }
    }

    /**
     * 创建线程工厂类
     * 虽然JDK提供了默认工厂类DefaultThreadFactory，但最好自定义实现，可以自定义线程名、对线程分组等。
     */
    static class MyThreadFactory implements ThreadFactory{

        /**
         * 工厂名，也可以理解为线程组名
         */
        private final String threadGroupName;

        /**
         * 原子类AtomicInteger实现自增，记录线程编号
         */
        private final AtomicInteger atomicInteger = new AtomicInteger(1);

        public MyThreadFactory(String name) {
            this.threadGroupName = name;
        }

        @Override
        public Thread newThread(Runnable r) {
            /**
             * 重写ThreadFactory的newThread，创建带有组名和id的线程。
             */
            String threadName = threadGroupName + atomicInteger.getAndIncrement();
            return new Thread(r,threadName);
        }
    }

    public static void main(String[] args) {
        /**
         * 线程工厂，用自定义的MyThreadFactory
         */
        ThreadFactory threadFactory = new MyThreadFactory("测试线程组");
        /**
         * 核心线程数量2
         */
        int corePoolSize=2;
        /**
         * 线程池内最大线程数量10
         */
        int maximumPoolSize=10;
        /**
         * JDK提供了四个可直接使用的队列实现，分别是：
         * 基于数组的有界队列ArrayBlockingQueue、
         * 基于链表的无界队列LinkedBlockingQueue、
         * 只有一个元素的同步队列SynchronousQueue、
         * 优先级队列PriorityBlockingQueue。
         * 这里使用队列长度为3的ArrayBlockingQueue队列
         */
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3);

        /**
         * 拒绝策略，当任务队列存满并且线程池个数达到maximunPoolSize后采取的策略。ThreadPoolExecutor中提供了四种拒绝策略，分别是：
         * 抛RejectedExecutionException异常的AbortPolicy(如果不指定的默认策略)、
         * 使用调用者所在线程来运行任务CallerRunsPolicy、
         * 丢弃一个等待执行的任务，然后尝试执行当前任务DiscardOldestPolicy、
         * 不动声色的丢弃并且不抛异常DiscardPolicy。
         * 这里使用默认的AbortPolicy策略。
         */
        RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy();

        /**
         * 构造方法创建线程池
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                60,
                TimeUnit.SECONDS,
                arrayBlockingQueue,
                threadFactory,
                rejectedExecutionHandler
        );

        /**
         * 通过线程池执行任务
         * 当前线程池最大线程数为10，阻塞队列大小为3
         * 所以当多于13个任务时，按拒绝策略抛出异常
         */
        for (int i = 0; i < 14; i++) {
            threadPoolExecutor.execute(new Task());
        }
		/**
         * 关闭线程池
         */
        threadPoolExecutor.shutdown();
        if (threadPoolExecutor.awaitTermination(3,TimeUnit.SECONDS)) {
            System.out.println("线程池已关闭");
        }
    }

}

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.zmxqq.test2$Task@277050dc rejected from java.util.concurrent.ThreadPoolExecutor@5c29bfd[Running, pool size = 10, active threads = 10, queued tasks = 3, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
	at com.zmxqq.test2.main(test2.java:112)
测试线程组1
测试线程组5
测试线程组6
测试线程组4
测试线程组3
测试线程组2
测试线程组9
测试线程组8
测试线程组10
测试线程组7
测试线程组1
测试线程组5
测试线程组6
线程池已关闭

因为任务数大于13，所以抛出RejectedExecutionException异常。

另外最后输出的三个线程1、5、6会停顿一下，因为当前线程池最大线程数为10，超过10的几个任务会在阻塞队列中等待空闲线程。

Executors创建线程池（不要用）

Executors中四种线程池

newFixedThreadPool，固定线程数量的线程池，使用于负载比较重的服务器。

newCachedThreadPool，缓存线程池，当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程，适用于提交短期的异步小程序，以及负载较轻的服务器

newSingleThreadPool，单线程池，需要保证顺序执行各个任务的场景。

newScheduledThreadPool，定时周期性的线程池。

实现方式：

• 实现Runnable接口或Callable接口，重写run方法或call方法；
• 使用Executors类中的newFixedThreadPool等方法创建一个指定线程数量的线程池；
• 调用线程池中的execute()方法执行由实现Runnable接口创建的线程；调用submit()方法执行由实现Callable接口创建的线程；
• 可以用Future接收实现Callable接口的线程的返回值；
• 调用线程池中的shutdown()方法关闭线程池。

public class test2 implements Callable<String> {

    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 5; i++) {
            test2 test2 = new test2();
            Future future = executorService.submit(test2);
            System.out.println(future.get());
        }
        executorService.shutdown();
    }
}
//pool-1-thread-1
//pool-1-thread-2
//pool-1-thread-3
//pool-1-thread-4
//pool-1-thread-1

Executors.newFixedThreadPool(4);创建了一个固定大小为4的线程池，所以第5次循环用的是第一个线程。

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

1）FixedThreadPool和SingleThreadPool:

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

2）CachedThreadPool和ScheduledThreadPool:

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

创建线程池对象，强烈建议通过使用ThreadPoolExecutor的构造方法创建，不要使用Executors