浅谈线程池

1.线程池的基本认识

1.1什么是线程池

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

1.2线程池的好处

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

2.Java中提供的线程池

Java中提供很多的线程池，这里主要介绍以下四种线程池

2.1 newFixedThreadPool

创建一个固定数量的线程池

代码示例

	public class ThreadPoolDemo implements  Runnable{

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 100; i++) {
            executorService.execute(new ThreadPoolDemo());
        }
        executorService.shutdown();
    }

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

输出结果：

2.2 newSingleThreadExecutor

创建一个只有一个的线程池

代码示例：

 public class ThreadPoolDemo implements  Runnable{

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new ThreadPoolDemo());
        }
        executorService.shutdown();
    }

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

输出结果：

2.3newCachedThreadPool

返回一个可以根据实际情况去调整大小的线程池，可以动态的扩展，多出来的线程池在使用后的一定时间内会被自动回收。

代码示例：

 public class ThreadPoolDemo implements  Runnable{

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new ThreadPoolDemo());
        }
        executorService.shutdown();
    }

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

输出结果：

2.4 newScheduledThreadPool

可以创建一个调度定时任务的线程池，可延迟执行和周期性执行

代码示例：

	public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        service.scheduleAtFixedRate(() -> {
        	// 每三秒执行一次
            System.out.println(System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName());
        }, 0, 3000, TimeUnit.MILLISECONDS);
    }

输出结果：

3.线程池的构造方法

我们从上面的四种创建方式跟进源码可以看到，都用到了ThreadPoolExecutor这个类 ，区别在于所用参数值与个数不一样，如下图所示：

参数代表的意义：

	public ThreadPoolExecutor(int corePoolSize, // 核心线程数量
                              int maximumPoolSize,// 最大线程数
                              long keepAliveTime,// 超时时间，超出核心线程数量以外的线程空余存活时间
                              TimeUnit unit, // 存活时间单位
                              BlockingQueue<Runnable> workQueue, // 保持执行任务的队列	
                              ThreadFactory threadFactory, // 创建新线程使用的工厂
                              RejectedExecutionHandler handler // 当任务无法执行时的处理方式)

4.线程池的原理

首先，线程池会判断是否已经超过了核心线程数量。
如果没有超过核心线程数，会创建一个线程并执行任务。一方面，会执行传进来的任务，另一方面也会从BlockingQueue<Runnable> workQueue 中去执行等待中的任务。
如果已经超过了核心线程数，且这个队列是有界队列，会判断当前队列是否已满，没有满的情况下会加入到这个队列中等待被空闲线程的调用。如果队列已满，会判断当前线程池是否已经超过最大线程数，就会采用一个拒绝策略，不会执行这个任务；如果没有超过最大线程数，就会创建一个线程（这个线程是可以被回收的）并执行当前任务，也会从队列中获取任务执行。

5.线程池的监控

上面说到的都是Java中自带的线程池，那么，我们可不可以自定义线程池呢，肯定是可以的，比如继承ThreadPoolExecutor。这样的好处是我们可以根据自己的业务去重写一些方法，比如shutdown，beforeExecute，afterExecute

代码示例

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
    public void shutdown() {
        super.shutdown();
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        // 任务执行开始会执行这个方法
        // TODO
    }

    @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());
    }
}

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

测试demo:

public class ThreadPoolDemo implements  Runnable{

    public static void main(String[] args) {
         ExecutorService executorService = ExcutorsSelf.newFixedThreadPool(3);
        for (int i = 0; i < 100; i++) {
            executorService.execute(new ThreadPoolDemo());
        }
        executorService.shutdown();
    }

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

输出结果：

6.带返回值的线程池处理

实际使用中可能需要获取一个线程的最终返回值，然后再进行其他业务处理,那么，可以采用下面的方式

public class CallableFutureDemo implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("hello DBL");
        return "DBL";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableFutureDemo callableFutureDemo = new CallableFutureDemo();
        ExecutorService service = Executors.newFixedThreadPool(1);
        FutureTask future = (FutureTask) service.submit(callableFutureDemo);
        System.out.println(future.get());
    }
}

运行结果：