深入理解Java的线程池概念及核心方法

线程

关于什么是线程我相信大家都知道，可是线程池可能还是有不明白的同学吧，这里我就简单介绍一下。线程池是一个“容器”，在我们使用线程的时候统一使用容器来创建并维护线程池，这样就有个好处我们的线程数量可以自己控制，并且空闲的线程可以回收再利用。

线程池代码

创建线程池一共有下面五种方式。

package com.hengyi.test;

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;

public class ExecutorsPoolController {

    public static void main(String[] args) {
        /**
         * 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
         * 那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线
         * 程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制
         * ，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
         */
        ExecutorService service = Executors.newCachedThreadPool();
        /**
         * 创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线
         * 程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程
         * 因为执行异常而结束，那么线程池会补充一个新线程。
         */
        ExecutorService service1  = Executors.newFixedThreadPool(100);
        /**
         * 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单
         * 线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新
         * 的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
         */
        ExecutorService service2 = Executors.newSingleThreadExecutor();

        /**
         * 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
         */
        ExecutorService service3 = Executors.newScheduledThreadPool(100);

        /**
         * ThreadPoolExecutor是JDK并发包提供的一个线程池服务，基于
         * ThreadPoolExecutor可以很容易将一个Runnable接口的任务
         * 放入线程池中。
         * 
         * 1. 参数解释
         * corePoolSize：         核心线程数，会一直存活，即使没有任务，线程池也会维护线程的最少数量
         * maximumPoolSize： 线程池维护线程的最大数量
         * keepAliveTime：      线程池维护线程所允许的空闲时间，当线程空闲时间达到keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。如果allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。
         * unit： 线程池维护线程所允许的空闲时间的单位、可选参数值为：TimeUnit中的几个静态属性：NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
         * workQueue： 线程池所使用的缓冲队列，常用的是：java.util.concurrent.ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue
         * handler： 线程池中的数量大于maximumPoolSize，对拒绝任务的处理策略，默认值ThreadPoolExecutor.AbortPolicy()。
         */
        ExecutorService service4 = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),100, 120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(1000));

        Future<String> future = service4.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                return "我是线程，我是执行结果";
            }

        });

        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        service3.execute(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("我是线程");
            }
        });
        /**
         *  submit execute
         *  submit会返回线程的执行结果
         */

    }

}