java经常使用的几种线程池比较

1. 为何使用线程池

诸如 Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器，这种方式多是经过网络协议（例如 HTTP、FTP 或 POP）、经过 JMS 队列或者可能经过轮询数据库。无论请求如何到达，服务器应用程序中常常出现的状况是：单个任务处理的时间很短而请求的数目倒是巨大的。

构建服务器应用程序的一个简单模型是：每当一个请求到达就建立一个新线程，而后在新线程中为请求服务。实际上对于原型开发这种方法工做得很好，但若是试图部署以这种方式运行的服务器应用程序，那么这种方法的严重不足就很明显。每一个请求对应一个线程（thread-per-request）方法的不足之一是：为每一个请求建立一个新线程的开销很大；为每一个请求建立新线程的服务器在建立和销毁线程上花费的时间和消耗的系统资源要比花在处理实际的用户请求的时间和资源更多。

除了建立和销毁线程的开销以外，活动的线程也消耗系统资源。在一个 JVM 里建立太多的线程可能会致使系统因为过分消耗内存而用完内存或“切换过分”。为了防止资源不足，服务器应用程序须要一些办法来限制任何给定时刻处理的请求数目。

线程池为线程生命周期开销问题和资源不足问题提供了解决方案。经过对多个任务重用线程，线程建立的开销被分摊到了多个任务上。其好处是，由于在请求到达时线程已经存在，因此无心中也消除了线程建立所带来的延迟。这样，就能够当即为请求服务，使应用程序响应更快。并且，经过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到得到一个线程来处理为止，从而能够防止资源不足。

2. 使用线程池的风险

虽然线程池是构建多线程应用程序的强大机制，但使用它并非没有风险的。用线程池构建的应用程序容易遭受任何其它多线程应用程序容易遭受的全部并发风险，诸如同步错误和死锁，它还容易遭受特定于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。

2.1 死锁

任何多线程应用程序都有死锁风险。当一组进程或线程中的每个都在等待一个只有该组中另外一个进程才能引发的事件时，咱们就说这组进程或线程 死锁了。死锁的最简单情形是：线程 A 持有对象 X 的独占锁，而且在等待对象 Y 的锁，而线程 B 持有对象 Y 的独占锁，却在等待对象 X 的锁。除非有某种方法来打破对锁的等待（Java 锁定不支持这种方法），不然死锁的线程将永远等下去。

虽然任何多线程程序中都有死锁的风险，但线程池却引入了另外一种死锁可能，在那种状况下，全部池线程都在执行已阻塞的等待队列中另外一任务的执行结果的任务，但这一任务却由于没有未被占用的线程而不能运行。当线程池被用来实现涉及许多交互对象的模拟，被模拟的对象能够相互发送查询，这些查询接下来做为排队的任务执行，查询对象又同步等待着响应时，会发生这种状况。

2.2 资源不足

线程池的一个优势在于：相对于其它替代调度机制（有些咱们已经讨论过）而言，它们一般执行得很好。但只有恰当地调整了线程池大小时才是这样的。线程消耗包括内存和其它系统资源在内的大量资源。除了 Thread 对象所需的内存以外，每一个线程都须要两个可能很大的执行调用堆栈。除此之外，JVM 可能会为每一个 Java 线程建立一个本机线程，这些本机线程将消耗额外的系统资源。最后，虽然线程之间切换的调度开销很小，但若是有不少线程，环境切换也可能严重地影响程序的性能。

若是线程池太大，那么被那些线程消耗的资源可能严重地影响系统性能。在线程之间进行切换将会浪费时间，并且使用超出比您实际须要的线程可能会引发资源匮乏问题，由于池线程正在消耗一些资源，而这些资源可能会被其它任务更有效地利用。除了线程自身所使用的资源之外，服务请求时所作的工做可能须要其它资源，例如 JDBC 链接、套接字或文件。这些也都是有限资源，有太多的并发请求也可能引发失效，例如不能分配 JDBC 链接。

2.3 并发错误

线程池和其它排队机制依靠使用 wait() 和 notify() 方法，这两个方法都难于使用。若是编码不正确，那么可能丢失通知，致使线程保持空闲状态，尽管队列中有工做要处理。使用这些方法时，必须格外当心。而最好使用现有的、已经知道能工做的实现，例如 util.concurrent 包。

2.4 线程泄漏

各类类型的线程池中一个严重的风险是线程泄漏，当从池中除去一个线程以执行一项任务，而在任务完成后该线程却没有返回池时，会发生这种状况。发生线程泄漏的一种情形出如今任务抛出一个 RuntimeException 或一个 Error 时。若是池类没有捕捉到它们，那么线程只会退出而线程池的大小将会永久减小一个。当这种状况发生的次数足够多时，线程池最终就为空，并且系统将中止，由于没有可用的线程来处理任务。

有些任务可能会永远等待某些资源或来自用户的输入，而这些资源又不能保证变得可用，用户可能也已经回家了，诸如此类的任务会永久中止，而这些中止的任务也会引发和线程泄漏一样的问题。若是某个线程被这样一个任务永久地消耗着，那么它实际上就被从池除去了。对于这样的任务，应该要么只给予它们本身的线程，要么只让它们等待有限的时间。

2.5 请求过载

仅仅是请求就压垮了服务器，这种状况是可能的。在这种情形下，咱们可能不想将每一个到来的请求都排队到咱们的工做队列，由于排在队列中等待执行的任务可能会消耗太多的系统资源并引发资源缺少。在这种情形下决定如何作取决于您本身；在某些状况下，您能够简单地抛弃请求，依靠更高级别的协议稍后重试请求，您也能够用一个指出服务器暂时很忙的响应来拒绝请求。

3. 有效使用线程池的准则

只要您遵循几条简单的准则，线程池能够成为构建服务器应用程序的极其有效的方法：

不要对那些同步等待其它任务结果的任务排队。这可能会致使上面所描述的那种形式的死锁，在那种死锁中，全部线程都被一些任务所占用，这些任务依次等待排队任务的结果，而这些任务又没法执行，由于全部的线程都很忙。

在为时间可能很长的操做使用合用的线程时要当心。若是程序必须等待诸如 I/O 完成这样的某个资源，那么请指定最长的等待时间，以及随后是失效仍是将任务从新排队以便稍后执行。这样作保证了：经过将某个线程释放给某个可能成功完成的任务，从而将最终取得某些进展。

理解任务。要有效地调整线程池大小，您须要理解正在排队的任务以及它们正在作什么。它们是 CPU 限制的（CPU-bound）吗？它们是 I/O 限制的（I/O-bound）吗？您的答案将影响您如何调整应用程序。若是您有不一样的任务类，这些类有着大相径庭的特征，那么为不一样任务类设置多个工做队列可能会有意义，这样能够相应地调整每一个池。

4. 线程池的大小设置

调整线程池的大小基本上就是避免两类错误：线程太少或线程太多。幸运的是，对于大多数应用程序来讲，太多和太少之间的余地至关宽。

请回忆：在应用程序中使用线程有两个主要优势，尽管在等待诸如 I/O 的慢操做，但容许继续进行处理，而且能够利用多处理器。在运行于具备 N 个处理器机器上的计算限制的应用程序中，在线程数目接近 N 时添加额外的线程可能会改善总处理能力，而在线程数目超过 N 时添加额外的线程将不起做用。事实上，太多的线程甚至会下降性能，由于它会致使额外的环境切换开销。

线程池的最佳大小取决于可用处理器的数目以及工做队列中的任务的性质。若在一个具备 N 个处理器的系统上只有一个工做队列，其中所有是计算性质的任务，在线程池具备 N 或 N+1 个线程时通常会得到最大的 CPU 利用率。

对于那些可能须要等待 I/O 完成的任务（例如，从套接字读取 HTTP 请求的任务），须要让池的大小超过可用处理器的数目，由于并非全部线程都一直在工做。经过使用概要分析，您能够估计某个典型请求的等待时间（WT）与服务时间（ST）之间的比例。若是咱们将这一比例称之为 WT/ST，那么对于一个具备 N 个处理器的系统，须要设置大约 N*(1+WT/ST) 个线程来保持处理器获得充分利用。

处理器利用率不是调整线程池大小过程当中的惟一考虑事项。随着线程池的增加，您可能会碰到调度程序、可用内存方面的限制，或者其它系统资源方面的限制，例如套接字、打开的文件句柄或数据库链接等的数目。

5. 经常使用的几种线程池

5.1 newCachedThreadPool

建立一个可缓存线程池，若是线程池长度超过处理须要，可灵活回收空闲线程，若无可回收，则新建线程。

这种类型的线程池特色是：

• 工做线程的建立数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
• 若是长时间没有往线程池中提交任务，即若是工做线程空闲了指定的时间(默认为1分钟)，则该工做线程将自动终止。终止后，若是你又提交了新的任务，则线程池从新建立一个工做线程。
• 在使用CachedThreadPool时，必定要注意控制任务的数量，不然，因为大量线程同时运行，颇有会形成系统瘫痪。

示例代码以下：

 1 package test;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4 public class ThreadPoolExecutorTest {
 5  public static void main(String[] args) {
 6   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
 7   for (int i = 0; i < 10; i++) {
 8    final int index = i;
 9    try {
10     Thread.sleep(index * 1000);
11    } catch (InterruptedException e) {
12     e.printStackTrace();
13    }
14    cachedThreadPool.execute(new Runnable() {
15     public void run() {
16      System.out.println(index);
17     }
18    });
19   }
20  }
21 }

5.2 newFixedThreadPool

建立一个指定工做线程数量的线程池。每当提交一个任务就建立一个工做线程，若是工做线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

FixedThreadPool是一个典型且优秀的线程池，它具备线程池提升程序效率和节省建立线程时所耗的开销的优势。可是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工做线程，还会占用必定的系统资源。

示例代码以下：

 

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  for (int i = 0; i < 10; i++) {
   final int index = i;
   fixedThreadPool.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

 

由于线程池大小为3，每一个任务输出index后sleep 2秒，因此每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置如Runtime.getRuntime().availableProcessors()。

 

5.3 newSingleThreadExecutor

建立一个单线程化的Executor，即只建立惟一的工做者线程来执行任务，它只会用惟一的工做线程来执行任务，保证全部任务按照指定顺序(FIFO, LIFO, 优先级)执行。若是这个线程异常结束，会有另外一个取代它，保证顺序执行。单工做线程最大的特色是可保证顺序地执行各个任务，而且在任意给定的时间不会有多个线程是活动的。

示例代码以下：

 

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
} 

 

5.4 newScheduleThreadPool

建立一个定长的线程池，并且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

延迟3秒执行，延迟执行示例代码以下：

 

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

 

表示延迟1秒后每3秒执行一次，按期执行示例代码以下：

 

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}