Java多线程——线程池

系统启动一个新线程的成本是比较高的，因为它涉及到与操作系统的交互。在这种情况下，使用线程池可以很好的提供性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。

与数据库连接池类似的是，线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象传给线程池，线程池就会启动一条线程来执行该对象的run方法，当run方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run方法。

除此之外，使用线程池可以有效地控制系统中并发线程的数量，但系统中包含大量并发线程时，会导致系统性能剧烈下降，甚至导致JVM崩溃。而线程池的最大线程数参数可以控制系统中并发的线程不超过此数目。

在JDK1.5之前，开发者必须手动的实现自己的线程池，从JDK1.5之后，Java内建支持线程池。

与多线程并发的所有支持的类都在java.lang.concurrent包中。我们可以使用里面的类更加的控制多线程的执行。

一、Executors类

JDK1.5中提供Executors工厂类来产生连接池，该工厂类中包含如下的几个静态工程方法来创建连接池：

1、public static ExecutorService newFixedThreadPool(int nThreads)：创建一个可重用的、具有固定线程数的线程池。

2、public static ExecutorService newSingleThreadExecutor()：创建一个只有单线程的线程池，它相当于newFixedThreadPool方法是传入的参数为1

3、public static ExecutorService newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。

4、public static ScheduledExecutorService newSingleThreadScheduledExecutor：创建只有一条线程的线程池，他可以在指定延迟后执行线程任务

5、public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)：创建具有指定线程数的线程池，它可以再指定延迟后执行线程任务，corePoolSize指池中所保存的线程数，即使线程是空闲的也被保存在线程池内。

上面的几个方法都有一个重载的方法，多传入一个ThreadFactory参数的重载方法，使用的比较少。

二、ExecutorService类

可以看到上面的5个方法中，前面3个方法的返回值都是一个ExecutorService对象。该ExecutorService对象就代表着一个尽快执行线程的线程池（只要线程池中有空闲线程立即执行线程任务），程序只要将一个Runnable对象或Callable对象提交给该线程池即可，该线程就会尽快的执行该任务。

ExecutorService有几个重要的方法：

方法摘要
 boolean isShutdown() 
          如果此执行程序已关闭，则返回 true。
 boolean isTerminated() 
          如果关闭后所有任务都已完成，则返回 true。
 void shutdown() 
          启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
 List<Runnable> shutdownNow() 
          试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
<T> Future<T>

submit(Callable<T> task) 
          提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。

 Future<?>submit(Runnable task) 
          提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。

<T> Future<T>

submit(Runnable task, T result) 
          提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。

更详细的参考JDK API文档。

submit方法是对 Executor接口execute方法的更好的封装，建议使用submit方法。

三、ScheduleExecutorService类

在上面的5个方法中，后面2个方法的返回值都是一个ScheduleExecutorService对象。ScheduleExecutorService代表可在指定延迟或周期性执行线程任务的线程池。

ScheduleExecutorService类是ExecutorService类的子类。所以，它里面也有直接提交任务的submit方法，并且新增了一些延迟任务处理的方法：

方法摘要
<V> ScheduledFuture<V>

schedule(Callable<V> callable, long delay, TimeUnit unit) 
          创建并执行在给定延迟后启用的 ScheduledFuture。

 ScheduledFuture<?>schedule(Runnable command, long delay, TimeUnit unit) 
          创建并执行在给定延迟后启用的一次性操作。 ScheduledFuture<?>scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 
          创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。 ScheduledFuture<?>scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 
          创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

下面看看线程池的简单使用：

1、固定大小的线程池：

[java] view plain copy

  1. package com.tao.test;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. public class PoolTest {
  5. public static void main(String[] args) {
  6. ExecutorService pool=Executors.newFixedThreadPool(5);//创建一个固定大小为5的线程池
  7. for(int i=0;i<7;i++){
  8. pool.submit(new MyThread());
  9. }
  10. pool.shutdown();
  11. }
  12. }
  13. class MyThread extends Thread{
  14. @Override
  15. public void run() {
  16. System.out.println(Thread.currentThread().getName()+"正在执行。。。");
  17. }
  18. }

输出结果：

[java] view plain copy

  1. pool-1-thread-1正在执行。。。
  2. pool-1-thread-3正在执行。。。
  3. pool-1-thread-2正在执行。。。
  4. pool-1-thread-4正在执行。。。
  5. pool-1-thread-4正在执行。。。
  6. pool-1-thread-5正在执行。。。
  7. pool-1-thread-1正在执行。。。

可以看到虽然我们呢创建了7个MyThread线程对象，但是由于受线程池的大小限制，只是开启了5个线程，这样就减少了并发线程的数量。

2、单任务线程池：

[java] view plain copy

  1. public class PoolTest {
  2. public static void main(String[] args) {
  3. ExecutorService pool=Executors.newSingleThreadExecutor();//创建一个单线程池
  4. for(int i=0;i<7;i++){
  5. pool.submit(new MyThread());
  6. }
  7. pool.shutdown();
  8. }
  9. }

输出结果：

[java] view plain copy

  1. pool-1-thread-1正在执行。。。
  2. pool-1-thread-1正在执行。。。
  3. pool-1-thread-1正在执行。。。
  4. pool-1-thread-1正在执行。。。
  5. pool-1-thread-1正在执行。。。
  6. pool-1-thread-1正在执行。。。
  7. pool-1-thread-1正在执行。。。

可以看到，线程池只开启了一个线程。

3、创建可变尺寸的线程池

[java] view plain copy

  1. public class PoolTest {
  2. public static void main(String[] args) {
  3. ExecutorService pool=Executors.newCachedThreadPool();
  4. for(int i=0;i<5;i++){
  5. pool.submit(new MyThread());
  6. }
  7. pool.shutdown();
  8. }
  9. }

看输出结果：

[java] view plain copy

  1. pool-1-thread-1正在执行。。。
  2. pool-1-thread-3正在执行。。。
  3. pool-1-thread-2正在执行。。。
  4. pool-1-thread-4正在执行。。。
  5. pool-1-thread-5正在执行。。。

可以看到，我们没有限制线程池的大小，但是它会根据需求而创建线程。

4、延迟线程池

[java] view plain copy

  1. public class PoolTest {
  2. public static void main(String[] args) {
  3. ScheduledExecutorService pool=Executors.newScheduledThreadPool(6);
  4. for(int i=0;i<4;i++){
  5. pool.submit(new MyThread());
  6. }
  7. pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);
  8. pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);
  9. pool.shutdown();
  10. }
  11. }

输出结果：

[java] view plain copy

  1. pool-1-thread-1正在执行。。。
  2. pool-1-thread-3正在执行。。。
  3. pool-1-thread-2正在执行。。。
  4. pool-1-thread-4正在执行。。。
  5. pool-1-thread-6正在执行。。。
  6. pool-1-thread-1正在执行。。。

可以明显看到，最后两个线程不是立即执行，而是延迟了1秒在执行的。

5、单任务延迟线程池

[java] view plain copy

  1. public class PoolTest {
  2. public static void main(String[] args) {
  3. ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();
  4. for(int i=0;i<4;i++){
  5. pool.submit(new MyThread());
  6. }
  7. pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);
  8. pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);
  9. pool.shutdown();
  10. }
  11. }

上面我们使用的是JDK帮我封装好的线程池，我们也可以自己定义线程池，查看源码，我们发现，Excutors里面的获得线程的静态方法，内部都是调用ThreadPoolExecutor的构造方法。比如：

[java] view plain copy

  1. public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
  2. return new ThreadPoolExecutor(nThreads, nThreads,
  3. 0L, TimeUnit.MILLISECONDS,
  4. new LinkedBlockingQueue<Runnable>(),
  5. threadFactory);
  6. }

可以看到，它是通过调用ThreadPoolExecutor的构造方法来返回一个线程池的。所以，我们也可以自己手动的调用ThreadPoolExecutor的各种构造方法，来定义自己的线程池规则，不过一般情况下，使用自带的线程池就够了，不需要自己来实现。

时间： 2024-11-08 20:15:09

Java多线程——线程池的相关文章

java多线程--线程池的使用

程序启动一个新线程的成本是很高的,因为涉及到要和操作系统进行交互,而使用线程池可以很好的提高性能,尤其是程序中当需要创建大量生存期很短的线程时,应该优先考虑使用线程池. 线程池的每一个线程执行完毕后,并不会死亡,会再次回到线程池中变成空闲状态,等待下一个对象来调用,类比于数据库连接池.JDK1.5以后,java内置线程池. JDK5新增了一个Executors工厂类来产生线程池,通过查文档我们发现,产生线程池很多方法,常用的有以下几个方法: public static ExecutorServi

跟我学Java多线程——线程池与堵塞队列

前言 上一篇文章中我们将ThreadPoolExecutor进行了深入的学习和介绍,实际上我们在项目中应用的时候非常少有直接应用ThreadPoolExecutor来创建线程池的.在jdk的api中有这么一句话"可是,强烈建议程序猿使用较为方便的 Executors 工厂方法Executors.newCachedThreadPool()(无界线程池,能够进行自己主动线程回收).Executors.newFixedThreadPool(int)(固定大小线程池)和Executors.newSing

跟我学Java多线程——线程池与阻塞队列

前言 上一篇文章中我们将ThreadPoolExecutor进行了深入的学习和介绍,实际上我们在项目中应用的时候很少有直接应用ThreadPoolExecutor来创建线程池的,在jdk的api中有这么一句话"但是,强烈建议程序员使用较为方便的 Executors 工厂方法Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收).Executors.newFixedThreadPool(int)(固定大小线程池)和Executors.newSingleT

java多线程 -- 线程池

第四种获取线程的方法:线程池,一个 ExecutorService,它使用可能的几个池线程之一执行每个提交的任务,通常使用 Executors 工厂方法配置. 线程池可以解决两个不同问题:由于减少了每个任务调用的开销,它们通常可以在执行大量异步任务时提供增强的性能,并且还可以提供绑定和管理资源(包括执行任务集时使用的线程)的方法.每个 ThreadPoolExecutor 还维护着一些基本的统计数据,如完成的任务数. 为了便于跨大量上下文使用,此类提供了很多可调整的参数和扩展钩子 (hook).

Java多线程-线程池ThreadPoolExecutor构造方法和规则

为什么用线程池 博客地址 http://blog.csdn.net/qq_25806863 原文地址 http://blog.csdn.net/qq_25806863/article/details/71126867 有时候,系统需要处理非常多的执行时间很短的请求,如果每一个请求都开启一个新线程的话,系统就要不断的进行线程的创建和销毁,有时花在创建和销毁线程上的时间会比线程真正执行的时间还长.而且当线程数量太多时,系统不一定能受得了. 使用线程池主要为了解决一下几个问题: 通过重用线程池中的线程

Java多线程-----线程池详解

1. 线程池的实现原理 提交一个任务到线程池中,线程池的处理流程如下: 判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务.如果核心线程都在执行任务,则进入下个流程 线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里.如果工作队列满了,则进入下个流程 判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务.如果已经满了,则交给饱和策略来处理这个任务    2. 线程

Java多线程——线程池使用示例

示例代码: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolTest { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); String[] nameArr = new String[] {

ExecutorService 建立多线程线程池的步骤

ExecutorService 建立多线程线程池的步骤: 线程池的作用: 线程池作用就是限制系统中执行线程的数量. 根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果:少了浪费了系统资源,多了造成系统拥挤效率不高.用线程池控制线程数量,其他线程排队等候.一个任务执行完毕,再从队列的中取最前面的任务开始执行.若队列中没有等待进程,线程池的这一资源处于等待.当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了:否则进入等待队列. 为什么要用线程池: 1.减少了创建和

线程池；java实现线程池原理

线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务.线程池线程都是后台线程.每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中.如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙.如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值.超过最大值的线程可以排队,但他们要等到其他线程完成后才启动. 组成部分 1.线程池