线程池介绍及使用

---

一、线程池概念

提前创建好若干个线程放在一个容器中。如果有任务需要处理，则将任务 直接分配给线程池中的线程来执行，任务处理完以后这个线程不会被销毁， 而是等待后续分配任务。

二、使用线程池的好处

• 降低创建线程和销毁线程的性能开销
• 提高响应速度，当有新任务需要执行是不需要等待线程创建就 可以立马执行
• 合理的设置线程池大小可以避免因为线程数超过硬件资源瓶颈 带来的问题

三、Java提供的四种线程池

1. newFixedThreadPool（固定大小的线程池）
2. newSingleThreadExecutor（只有一个线程数量的线程池）
3. newCachedThreadPool（可根据实际并发量决定大小的线程池）
4. newScheduledThreadPool（定时调度的线程池）

四、线程池构造器

public ThreadPoolExecutor(int corePoolSize,//核心线程数量
                              int maximumPoolSize,//最大线程数
                              long keepAliveTime,//超过时间，超出核心线程数量以外的线程空余存活时间 
                              TimeUnit unit,//存活时间单位
                              BlockingQueue<Runnable> workQueue,//保存执行任务的队列（单链表）
                              ThreadFactory threadFactory)//创建新线程使用的工厂
 {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

五、案例

1.FixedThreadPool

public class FixedThreadPoolTest implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(3);
        //可以提前预热所有核心线程
        executorService.prestartCoreThread();
        for (int i = 0; i < 20; i++) {
            executorService.execute(new FixedThreadPoolTest());
        }
        //停止接收新的submit的任务
        //已经提交的任务（包括正在跑的和队列中等待的）,会继续执行完成
        executorService.shutdown();
    }
}

2.线程池的监控

public class ExecutorsSelf {
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolSelf(nThreads, nThreads,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
    }
}

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

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        //任务执行结束
        System.out.println("初始线程数:"+this.getPoolSize());
        System.out.println("核心线程数："+this.getCorePoolSize());
        System.out.println("正在执行的任务数量："+this.getActiveCount());
        System.out.println("已经执行的任务数："+this.getCompletedTaskCount());
        System.out.println("任务总数"+this.getTaskCount());
    }
}

3.线程池+Callable

public class CallableFutureDemo implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "call";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //使用线程池
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(1);
        FutureTask future = (FutureTask) executorService.submit(new CallableFutureDemo());
        executorService.shutdown();
        System.out.println(future.get());//这里会进行阻塞
        //未使用线程池
        CallableFutureDemo callableFutureDemo = new CallableFutureDemo();
        FutureTask futureTask = new FutureTask(callableFutureDemo);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}