Java线程池ThreadPoolExecutor的简单使用

什么时候使用线程池

1.服务器接收大量请求时
2.需要创建5个以上的线程时, 就可以使用线程池来管理

ThreadPoolExecutor

构造函数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
	// ......
}

参数	描述
corePoolSize	核心线程数量，线程池初始化后, 默认没有任务线程, 等有任务的时候, 再创建新线程去执行, 当线程数量小于corePoolSize, 也不会销毁空闲线程
maximumPoolSize	最大线程数量，当任务队列也满的情况下，线程池会在核心线程数量的基础上新增加线程, 但是这个数量有一个限制, 那就是maximumPoolSize
keepAliveTime	多于corePoolSize的线程超过keepAliveTime, 它们就会终止
unit	空闲时间单位
workQueue	任务存储队列，有3中常见的队列类型, SynchronousQueue(直接交接); LinkedBlockingQueue(无界队列); ArrayBlockingQueue(有界队列);
threadFactory	通过这个参数可以自定义如何创建线程, 例如可以给线程指定一个有意义的名字
handler	通过这个参数可以自定义任务的拒绝策略

线程创建规则

1. 如果线程数量小于corePoolSize, 即使其他工作线程处于空闲状态, 也会创建一个新线程来运行新任务
2. 如果线程数量等于或大于corePoolSize但是小于maxPoolSize，则将任务放入队列
3. 如果队列已满, 并且线程数小于maxPoolSize, 则创建一个新的线程来运行任务
4. 如果队列已满, 且线程数量大于或等于maxPoolSize, 则拒绝该任务

线程创建

/*
 * 如何创建线程
 */ 
class MyThreadFactory implements ThreadFactory {
    private AtomicInteger mThreadNum = new AtomicInteger(1);
    @Override
    public Thread newThread(Runnable r) {
        //自定义线程名称
        Thread t = new Thread(r, "thread - " + mThreadNum.getAndIncrement());
        System.out.println("thread - " + mThreadNum.getAndIncrement() + " 被创建了 ");
        return t;
    }
}

任务队列

队列类型	描述
SynchronousQueue	直接交接，没有任何存放任务的能力
LinkedBlockingQueue	无界队列，无限大
ArrayBlockingQueue	有界队列，指定大小

拒绝策略

/*
 * 任务拒绝策略
 */
class MyRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        //拒绝逻辑
        System.out.println(r.toString() + "  被拒绝了 ");
    }
}

简单使用

/*
 * 如何创建线程
 */ 
class MyThreadFactory implements ThreadFactory {
    private AtomicInteger mThreadNum = new AtomicInteger(1);
    @Override
    public Thread newThread(Runnable r) {
        //自定义线程名称
        Thread t = new Thread(r, "thread - " + mThreadNum.getAndIncrement());
        System.out.println("thread - " + mThreadNum.getAndIncrement() + " 被创建了 ");
        return t;
    }
}

/*
 * 任务拒绝策略
 */
class MyRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        //拒绝逻辑
        System.out.println(r.toString() + "  被拒绝了 ");
    }
}

/*
 * 任务
 */ 
class MyTask implements Runnable {

    private String name;
    public MyTask(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(3000);
            System.out.println(name + " 运行结束... ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "MyTask [name=" + name + "]";
    }
}


class ThreadPoolExecutorTest {
    public static void main(String[] args) throws InterruptedException {

        //创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10),//队列长度为10
                new MyThreadFactory(), //一般使用默认即可
                new MyRejectedExecutionHandler());

        //无论有没有任务，先创建corePoolSize个线程
        executor.prestartAllCoreThreads();

        //创建任务并交个线程池中的线程执行
        for (int i = 0; i < 30; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }

        //阻塞主线程
        while (true){
            Thread.sleep(3000);
            System.out.println(executor.getPoolSize());//查看线程池中的线程数量
        }
    }
}

关闭线程池

ExecutorService executorService = Executors.newFixedThreadPool(10);

//会等待正在执行的任务执行完毕才关闭
executorService.shutdown();

//立即关闭，无论当前是否有正在执行的任务
executorService.shutdownNow();

//查看当前线程池是否已经关闭
executorService.isShutdown()
executorService.isTerminated()
executorService.awaitTermination(10L, TimeUnit.SECONDS)

钩子函数

可以使用钩子函数在线程池中的线程执行之前进行一些操作，具体测试代码如下

public class PauseableThreadPoolTest extends ThreadPoolExecutor {

    //Lock锁
    private final ReentrantLock lock = new ReentrantLock();
    //Condition，让线程处于等待状态或唤醒等待线程
    private Condition unpaused = lock.newCondition();
    //设置优雅暂停线程池中任务执行的的标志位，等于true时暂停线程池中的线程任务执行
    private boolean isPaused;

    public PauseableThreadPoolTest(int corePoolSize, int maximumPoolSize,
                                   long keepAliveTime, TimeUnit unit,
                                   BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public PauseableThreadPoolTest(int corePoolSize, int maximumPoolSize,
                                   long keepAliveTime, TimeUnit unit,
                                   BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public PauseableThreadPoolTest(int corePoolSize, int maximumPoolSize,
                                   long keepAliveTime, TimeUnit unit,
                                   BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public PauseableThreadPoolTest(int corePoolSize, int maximumPoolSize,
                                   long keepAliveTime, TimeUnit unit,
                                   BlockingQueue<Runnable> workQueue,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    /**
     * 每次线程执行前都会调用该方法
     */
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        lock.lock();
        try {
            while (isPaused){
                //如果isPaused=true, 让线程进入等待状态
                unpaused.await();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 暂停
     */
    private void pause(){
        lock.lock();
        try {
            isPaused = true;
        }finally {
            lock.unlock();
        }
    }

    /**
     * 唤醒
     */
    private void resume(){
        lock.lock();
        try {
            isPaused = false;
            unpaused.signalAll();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {

        //创建线程池
        PauseableThreadPoolTest pauseableThreadPoolTest =
                new PauseableThreadPoolTest(10, 20,
                        10L, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

        //创建任务并放入线程池中执行
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程被执行......");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for (int i = 0; i < 1000; i++) {
            pauseableThreadPoolTest.execute(runnable);
        }

        Thread.sleep(500);
        pauseableThreadPoolTest.pause();
        System.out.println("线程池中的线程进入休眠状态，任务暂停执行......");

        Thread.sleep(3000);
        pauseableThreadPoolTest.resume();
        System.out.println("线程池中的线程会唤醒了，任务继续执行......");
    }

}