java并发编程（十九）- 线程池（ThreadPoolExecutor）详细使用-CFANZ编程社区

线程池的创建

ThreadPoolExecutor，jdk所有线程池实现的父类

各个参数含义

int corePoolSize ：线程池中核心线程数，< corePoolSize ，就会创建新线程，= corePoolSize ，这个任务就会保存到BlockingQueue，如果调用prestartAllCoreThreads（）方法就会一次性的启动corePoolSize 个数的线程。

int maximumPoolSize, 允许的最大线程数，BlockingQueue也满了，< maximumPoolSize时候就会再次创建新的线程

long keepAliveTime, 线程空闲下来后，存活的时间，这个参数只在> corePoolSize才有用

TimeUnit unit, 存活时间的单位值

BlockingQueue<Runnable> workQueue, 保存任务的阻塞队列

ThreadFactory threadFactory, 创建线程的工厂，给新建的线程赋予名字

RejectedExecutionHandler handler ：饱和策略

AbortPolicy ：直接抛出异常，默认；

CallerRunsPolicy：用调用者所在的线程来执行任务

DiscardOldestPolicy：丢弃阻塞队列里最老的任务，队列里最靠前的任务

DiscardPolicy ：当前任务直接丢弃

实现自己的饱和策略，实现RejectedExecutionHandler接口即可

提交任务

execute(Runnable command) 不需要返回

Future<T> submit(Callable<T> task) 需要返回

关闭线程池

shutdown(),shutdownNow();

shutdownNow():设置线程池的状态，还会尝试停止正在运行或者暂停任务的线程

shutdown()设置线程池的状态，只会中断所有没有执行任务的线程

使用线程池代码：

package com.caojiulu;

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.caojiulu.SleepTools;

/**
 *@author caojiulu 
 *
 *类说明：线程池的使用
 */
public class UseThreadPool {
    //工作线程
    static class Worker implements Runnable
    {
        private String taskName;
        private Random r = new Random();

        public Worker(String taskName){
            this.taskName = taskName;
        }

        public String getName() {
            return taskName;
        }

        @Override
        public void run(){
            System.out.println(Thread.currentThread().getName()
                    +" process the task : " + taskName);
            SleepTools.ms(r.nextInt(100)*5);
        }
    }
    
    static class CallWorker implements Callable<String>{
        
        private String taskName;
        private Random r = new Random();

        public CallWorker(String taskName){
            this.taskName = taskName;
        }

        public String getName() {
            return taskName;
        }       

        @Override
        public String call() throws Exception {
            System.out.println(Thread.currentThread().getName()
                    +" process the task : " + taskName);
            return Thread.currentThread().getName()+":"+r.nextInt(100)*5;
        }
        
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        ExecutorService pool = new ThreadPoolExecutor(2,4,3,TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        //ExecutorService pool = Executors.newFixedThreadPool(5);
        for(int i=0;i<6;i++) {
            Worker worker = new Worker("worker_"+i);
            pool.execute(worker);
        }
        for(int i=0;i<6;i++) {
            CallWorker callWorker = new CallWorker("callWorker_"+i);
            Future<String> result = pool.submit(callWorker);
            System.out.println(result.get());
        }
        pool.shutdown();
    }
}