Java 理论与实践：线程池与工作队列(zz)

djsl6071

浏览: 578779 次
性别:
来自: 厦门

最近访客更多访客>>

liyawei

zhangqijava

fooler5

linhaicheng2007

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

工作 Java 多线程 fckeditor 应用服务器

Java 理论与实践: 线程池与工作队列<o:p></o:p>

线程池有助于实现最佳资源利用率<o:p></o:p>

<v:shapetype o:spt="75" coordsize="21600,21600" filled="f" stroked="f" id="_x0000_t75" path="m@4@5l@4@11@9@11@9@5xe" o:preferrelative="t"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" o:connecttype="rect" gradientshapeok="t"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><v:shape id="_x0000_i1025" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 4.5pt"><v:imagedata o:href="http://www.ibm.com/i/c.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image001.gif"></v:imagedata></v:shape><o:p></o:p>

<o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1026" type="#_x0000_t75" alt="" style="WIDTH: 7.5pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://www.ibm.com/i/c.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image001.gif"></v:imagedata></v:shape><o:p></o:p>

级别: 初级<o:p></o:p>

Brian Goetz, 首席顾问, Quiotix Corp<o:p></o:p>

2002 年 10 月 12 日<o:p></o:p>

贴在我们多线程 Java 编程论坛上最常见的问题之一是“怎样创建线程池？”。几乎在每个服务器应用程序中都会出现线程池和工作队列问题。本文中，Brian Goetz 探讨了线程池的动机、一些基本实现和调优技术以及一些要避免的常见危险。<o:p></o:p>

<v:shape id="_x0000_i1027" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

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

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

除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。在一个 JVM 里创建太多的线程可能会导致系统由于过度消耗内存而用完内存或“切换过度”。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目。<o:p></o:p>

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

<o:p> </o:p>

<v:shape id="_x0000_i1028" type="#_x0000_t75" alt="" style="WIDTH: 600pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://www.ibm.com/i/v14/rules/blue_rule.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image005.gif"></v:imagedata></v:shape>
<v:shape id="_x0000_i1029" type="#_x0000_t75" alt="" style="WIDTH: 6pt; HEIGHT: 4.5pt"><v:imagedata o:href="http://www.ibm.com/i/c.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image001.gif"></v:imagedata></v:shape><o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1030" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

线程池远不是服务器应用程序内使用多线程的唯一方法。如同上面所提到的，有时，为每个新任务生成一个新线程是十分明智的。然而，如果任务创建过于频繁而任务的平均处理时间过短，那么为每个任务生成一个新线程将会导致性能问题。<o:p></o:p>

另一个常见的线程模型是为某一类型的任务分配一个后台线程与任务队列。AWT 和 Swing 就使用这个模型，在这个模型中有一个 GUI 事件线程，导致用户界面发生变化的所有工作都必须在该线程中执行。然而，由于只有一个 AWT 线程，因此要在 AWT 线程中执行任务可能要花费相当长时间才能完成，这是不可取的。因此，Swing 应用程序经常需要额外的工作线程，用于运行时间很长的、同 UI 有关的任务。<o:p></o:p>

每个任务对应一个线程方法和单个后台线程（single-background-thread）方法在某些情形下都工作得非常理想。每个任务一个线程方法在只有少量运行时间很长的任务时工作得十分好。而只要调度可预见性不是很重要，则单个后台线程方法就工作得十分好，如低优先级后台任务就是这种情况。然而，大多数服务器应用程序都是面向处理大量的短期任务或子任务，因此往往希望具有一种能够以低开销有效地处理这些任务的机制以及一些资源管理和定时可预见性的措施。线程池提供了这些优点。<o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1031" type="#_x0000_t75" alt="" style="WIDTH: 600pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://www.ibm.com/i/v14/rules/blue_rule.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image005.gif"></v:imagedata></v:shape>
<v:shape id="_x0000_i1032" type="#_x0000_t75" alt="" style="WIDTH: 6pt; HEIGHT: 4.5pt"><v:imagedata o:href="http://www.ibm.com/i/c.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image001.gif"></v:imagedata></v:shape><o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1033" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

就线程池的实际实现方式而言，术语“线程池”有些使人误解，因为线程池“明显的”实现在大多数情形下并不一定产生我们希望的结果。术语“线程池”先于 Java 平台出现，因此它可能是较少面向对象方法的产物。然而，该术语仍继续广泛应用着。<o:p></o:p>

虽然我们可以轻易地实现一个线程池类，其中客户机类等待一个可用线程、将任务传递给该线程以便执行、然后在任务完成时将线程归还给池，但这种方法却存在几个潜在的负面影响。例如在池为空时，会发生什么呢？试图向池线程传递任务的调用者都会发现池为空，在调用者等待一个可用的池线程时，它的线程将阻塞。我们之所以要使用后台线程的原因之一常常是为了防止正在提交的线程被阻塞。完全堵住调用者，如在线程池的“明显的”实现的情况，可以杜绝我们试图解决的问题的发生。<o:p></o:p>

我们通常想要的是同一组固定的工作线程相结合的工作队列，它使用 wait() 和 notify() 来通知等待线程新的工作已经到达了。该工作队列通常被实现成具有相关监视器对象的某种链表。清单 1 显示了简单的合用工作队列的示例。尽管 Thread API 没有对使用 Runnable 接口强加特殊要求，但使用 Runnable 对象队列的这种模式是调度程序和工作队列的公共约定。 <o:p></o:p>

<v:shape id="_x0000_i1034" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

<o:p> </o:p>

public class WorkQueue<o:p></o:p>

{<o:p></o:p>

private final int nThreads;<o:p></o:p>

private final PoolWorker[] threads;<o:p></o:p>

private final LinkedList queue;<o:p></o:p>

<o:p> </o:p>

public WorkQueue(int nThreads)<o:p></o:p>

{<o:p></o:p>

this.nThreads = nThreads;<o:p></o:p>

queue = new LinkedList();<o:p></o:p>

threads = new PoolWorker[nThreads];<o:p></o:p>

<o:p> </o:p>

for (int i=0; i<nThreads; i++) {<o:p></o:p>

threads[i] = new PoolWorker();<o:p></o:p>

threads[i].start();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

public void execute(Runnable r) {<o:p></o:p>

synchronized(queue) {<o:p></o:p>

queue.addLast(r);<o:p></o:p>

queue.notify();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

private class PoolWorker extends Thread {<o:p></o:p>

public void run() {<o:p></o:p>

Runnable r;<o:p></o:p>

<o:p> </o:p>

while (true) {<o:p></o:p>

synchronized(queue) {<o:p></o:p>

while (queue.isEmpty()) {<o:p></o:p>

try<o:p></o:p>

{<o:p></o:p>

queue.wait();<o:p></o:p>

}<o:p></o:p>

catch (InterruptedException ignored)<o:p></o:p>

{<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

r = (Runnable) queue.removeFirst();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

// If we don't catch RuntimeException, <o:p></o:p>

// the pool could leak threads<o:p></o:p>

try {<o:p></o:p>

r.run();<o:p></o:p>

}<o:p></o:p>

catch (RuntimeException e) {<o:p></o:p>

// You might want to log something here<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

您可能已经注意到了清单 1 中的实现使用的是 notify() 而不是 notifyAll() 。大多数专家建议使用 notifyAll() 而不是 notify() ，而且理由很充分：使用 notify() 具有难以捉摸的风险，只有在某些特定条件下使用该方法才是合适的。另一方面，如果使用得当， notify() 具有比 notifyAll() 更可取的性能特征；特别是， notify() 引起的环境切换要少得多，这一点在服务器应用程序中是很重要的。 <o:p></o:p>

清单 1 中的示例工作队列满足了安全使用 notify() 的需求。因此，请继续，在您的程序中使用它，但在其它情形下使用 notify() 时请格外小心。 <o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1035" type="#_x0000_t75" alt="" style="WIDTH: 600pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://www.ibm.com/i/v14/rules/blue_rule.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image005.gif"></v:imagedata></v:shape>
<v:shape id="_x0000_i1036" type="#_x0000_t75" alt="" style="WIDTH: 6pt; HEIGHT: 4.5pt"><v:imagedata o:href="http://www.ibm.com/i/c.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image001.gif"></v:imagedata></v:shape><o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1037" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

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

<v:shape id="_x0000_i1038" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

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

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

<v:shape id="_x0000_i1039" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

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

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

<v:shape id="_x0000_i1040" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

线程池和其它排队机制依靠使用 wait() 和 notify() 方法，这两个方法都难于使用。如果编码不正确，那么可能丢失通知，导致线程保持空闲状态，尽管队列中有工作要处理。使用这些方法时，必须格外小心；即便是专家也可能在它们上面出错。而最好使用现有的、已经知道能工作的实现，例如在下面的无须编写您自己的池中讨论的 util.concurrent 包。 <o:p></o:p>

<v:shape id="_x0000_i1041" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

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

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

<v:shape id="_x0000_i1042" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

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

<o:p> </o:p>

<v:shape id="_x0000_i1043" type="#_x0000_t75" alt="" style="WIDTH: 600pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://www.ibm.com/i/v14/rules/blue_rule.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image005.gif"></v:imagedata></v:shape>
<v:shape id="_x0000_i1044" type="#_x0000_t75" alt="" style="WIDTH: 6pt; HEIGHT: 4.5pt"><v:imagedata o:href="http://www.ibm.com/i/c.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image001.gif"></v:imagedata></v:shape><o:p></o:p>

<o:p> </o:p>

<v:shape id="_x0000_i1045" type="#_x0000_t75" alt="" style="WIDTH: 0.75pt; HEIGHT: 0.75pt"><v:imagedata o:href="http://writeblog.csdn.net/Editor/FCKeditor/editor/images/spacer.gif" src="file:///C:\DOCUME~1\matthew\LOCALS~1\Temp\msohtml1\01\clip_image004.gif"></v:imagedata></v:shape><o:p></o:p>

只要您遵循几条简单的准则，线程池可以成为构建服务器应用程序的极其有效的方法：<o:p></o:p>

不要对那些同步等待其它任务结果的任务排队。这可能会导致上面所描述的那种形式的死锁，在那种死锁中，所有线程都被一些任务所占用，这些任务依次等待排队任务的结果，而这些任务又无法执行，因为所有的线程都很忙。 <o:p></o:p>
在为时间可能很长的操作使用合用的线程时要小心。如果程序必须等待诸如 I/O 完成这样的某个资源，那么请指定最长的等待时间，以及随后是失效还是将任务重新排队以便稍后执行。这样做保证了：通过将某个线程释放给某个可能成功完成的任务，从而将最终取得某些进展。

分享到：