java 线程工厂_Java并发编程：Java的四种线程池的使用，以及自己设置线程工厂...

引言

通过前面的文章，我们学习了Executor框架中的核心类ThreadPoolExecutor ，对于线程池的核心调度机制有了肯定的理解，并且成功使用ThreadPoolExecutor 创立了线程池。

而在Java中，除了ThreadPoolExecutor ，Executor框架中还提供了四种线程池，这四种线程池都是直接或者间接配置ThreadPoolExecutor的参数实现的，对于ThreadPoolExecutor类不熟习的读者可以参考Java并发编程：Java线程池核心ThreadPoolExecutor的使用和原理分析

四种线程池

四种线程池分别是：newCachedThreadPool、newFixedThreadPool 、newScheduledThreadPool 和newSingleThreadExecutor ，下面对这几个线程池逐个讲解。

newCachedThreadPool：可缓存的线程池

源码：public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue());}

newCachedThreadPool的方法中是返回一个ThreadPoolExecutor实例，从源码中可以看出该线程池的特点：

1、该线程池的核心线程数量是0，线程的数量最高可以达到Integer 类型最大值；

2、创立ThreadPoolExecutor实例时传过去的参数是一个SynchronousQueue实例，说明在创立任务时，若存在空闲线程就复用它，没有的话再新建线程。

3、线程处于闲置状态超过60s的话，就会被销毁。

用法：public static void main(String[] args) { //定义ExecutorService实例 ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { final int index = i; try { Thread.sleep(index * 1000); } catch (InterruptedException e) { e.printStackTrace(); } //调用execute方法 cachedThreadPool.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread() + ":" + index); } }); }}

上面的代码由于每次循环都是隔一秒执行，这个时间足够之前的线程工作完毕，并在新循环中复用这个线程，程序的运行结果如下：Thread[pool-1-thread-1,5,main]:0Thread[pool-1-thread-1,5,main]:1Thread[pool-1-thread-1,5,main]:2Thread[pool-1-thread-1,5,main]:3Thread[pool-1-thread-1,5,main]:4Thread[pool-1-thread-1,5,main]:5Thread[pool-1-thread-1,5,main]:6Thread[pool-1-thread-1,5,main]:7Thread[pool-1-thread-1,5,main]:8Thread[pool-1-thread-1,5,main]:9

newFixedThreadPool：定长线程池

源码：public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());}

线程池特点：

1、线程池的最大线程数等于核心线程数，并且线程池的线程不会由于闲置超时被销毁。

2、使用的列队是LinkedBlockingQueue，表示假如当前线程数小于核心线程数，那么即便有空闲线程也不会复用线程去执行任务，而是创立新的线程去执行任务。假如当前执行任务数量大于核心线程数，此时再提交任务就在队列中等待，直到有可用线程。

用法：public static void main(String[] args) { ExecutorService cachedThreadPool = Executors.newFixedThreadPool(3); for (int i = 0; i < 10; i++) { final int index = i; try { Thread.sleep(index * 1000); } catch (InterruptedException e) { e.printStackTrace(); } cachedThreadPool.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread() + ":" + index); } }); }}

定义一个线程数为3的线程池，循环10次执行，可以发现运行的线程永远只有三个，结果如下：Thread[pool-1-thread-1,5,main]:0Thread[pool-1-thread-2,5,main]:1Thread[pool-1-thread-3,5,main]:2Thread[pool-1-thread-1,5,main]:3Thread[pool-1-thread-2,5,main]:4Thread[pool-1-thread-3,5,main]:5Thread[pool-1-thread-1,5,main]:6Thread[pool-1-thread-2,5,main]:7Thread[pool-1-thread-3,5,main]:8Thread[pool-1-thread-1,5,main]:9

newSingleThreadExecutor：单线程线程池

源码：public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));}

从源码即可以看出，该线程池基本就是只有一个线程数的newFixedThreadPool，它只有一个线程在工作，所有任务按照指定顺序执行。

用法：

和newFixedThreadPool相似，只是一直只有一个线程在工作，这里就不贴代码了。

newScheduledThreadPool：支持定时的定长线程池

源码：public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize);}public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());}public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); }

newScheduledThreadPool的方法不是直接返回一个ThreadPoolExecutor实例，而是通过有定时功能的ThreadPoolExecutor，也就是ScheduledThreadPoolExecutor 来返回ThreadPoolExecutor实例，从源码中可以看出：

1、该线程池可以设置核心线程数量，最大线程数与newCachedThreadPool一样，都是Integer.MAX_VALUE。

2、该线程池采用的队列是DelayedWorkQueue，具备推迟和定时的作用。

用法：public static void main(String[] args) { ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3); //推迟3秒执行，只执行一次 ((ScheduledExecutorService) scheduledThreadPool).schedule(new Runnable() { @Override public void run() { System.out.println("推迟========"); } },3,TimeUnit.SECONDS); //推迟1秒后每隔两秒执行一次 ((ScheduledExecutorService) scheduledThreadPool).scheduleAtFixedRate(new Runnable() { @Override public void run() { System.out.println("执行============"); } },1,2,TimeUnit.SECONDS); //单位是秒}

自己设置ThreadFactory

四种线程池的使用就说到这里了，值得说明的是，除了上面的参数外，Executors类中还给这四种线程池提供了可传ThreadFactory的重载方法，以下是它们的源码：public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory));}public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue(), threadFactory);}public static ScheduledExecutorService newScheduledThreadPool( int corePoolSize, ThreadFactory threadFactory) { return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);}public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory);}

ThreadFactory是一个接口类，也就是我们经常说的线程工厂，只有一个方法，可以用于创立线程：Thread newThread(Runnable r);

默认情况下，ThreadPoolExecutor构造器传入的ThreadFactory 参数是Executors类中的defaultThreadFactory()，相当于一个线程工厂，帮我们创立了线程池中所需的线程。

除此之外，我们也可以自己设置ThreadFactory，并根据自己的需要来操作线程，下面是实例代码：public static void main(String[] args) { ExecutorService service = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, new SynchronousQueue(), new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread t = new Thread(r); System.out.println("我是线程" + r); return t; } } ); //用lambda表达式编写方法体中的逻辑 Runnable run = () -> { try { Thread.sleep(1000); System.out.println(Thread.currentThread().getName() + "正在执行"); } catch (InterruptedException e) { e.printStackTrace(); } }; for (int i = 0; i < 5; i++) { service.submit(run); } //这里肯定要做关闭 service.shutdown();}

运行代码后，控制行会输出五行 “我是线程java.util.concurrent.ThreadPoolExecutor。。。。。”的信息，也证实了我们自己设置的ThreadFactory起到了作用。