Java编程思想第4版[中文版](PDF格式)-第122部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！


null，使垃圾收集器能够将其清除，然后调用对象的interrupt（）方法。如果是首次按下按钮，我们会看到　

线程正常退出。但在没有可供“杀死”的线程以后，看到的便只是按钮被按下而已。　　

suspend（）和resume（）　方法天生容易发生死锁。调用　suspend（）的时候，目标线程会停下来，但却仍然持有在　

这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被“挂起”的线程恢复运行。对任何　

线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成令人难堪的死锁。所　

以我们不应该使用suspend（）和　resume（），而应在自己的Thread　类中置入一个标志，指出线程应该活动还是　

挂起。若标志指出线程应该挂起，便用wait（）命其进入等待状态。若标志指出线程应当恢复，则用一个　

notify（）重新启动线程。我们可以修改前面的Counter2。java　来实际体验一番。尽管两个版本的效果是差不　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　519　


…………………………………………………………Page　521……………………………………………………………

多的，但大家会注意到代码的组织结构发生了很大的变化——为所有“听众”都使用了匿名的内部类，而且　

Thread　是一个内部类。这使得程序的编写稍微方便一些，因为它取消了　Counter2。java　中一些额外的记录工　

作。　　

　　

//：　Suspend。java　　

//　The　alternative　approach　to　using　suspend（）　　

//　and　resume（）；　which　have　been　deprecated　　

//　in　Java　1。2。　　

import　java。awt。*；　　

import　java。awt。event。*；　　

import　java。applet。*；　　

　　

public　class　Suspend　extends　Applet　｛　　

　　private　TextField　t　=　new　TextField（10）；　　

　　private　Button　　　

　　　　suspend　=　new　Button（〃Suspend〃）；　　

　　　　resume　=　new　Button（〃Resume〃）；　　

　　class　Suspendable　extends　Thread　｛　　

　　　　private　int　count　=　0；　　

　　　　private　boolean　suspended　=　false；　　

　　　　public　Suspendable（）　｛　start（）；　｝　　

　　　　public　void　fauxSuspend（）　｛　　　

　　　　　　suspended　=　true；　　

　　　　｝　　

　　　　public　synchronized　void　fauxResume（）　｛　　

　　　　　　suspended　=　false；　　

　　　　　　notify（）；　　

　　　　｝　　

　　　　public　void　run（）　｛　　

　　　　　　while　（true）　｛　　

　　　　　　　　try　｛　　

　　　　　　　　　　sleep（100）；　　

　　　　　　　　　　synchronized（this）　｛　　

　　　　　　　　　　　　while（suspended）　　

　　　　　　　　　　　　　　wait（）；　　

　　　　　　　　　　｝　　

　　　　　　　　｝　catch　（InterruptedException　e）｛｝　　

　　　　　　　　t。setText（Integer。toString（count＋＋））；　　

　　　　　　｝　　

　　　　｝　　

　　｝　　　

　　private　Suspendable　ss　=　new　Suspendable（）；　　

　　public　void　init（）　｛　　

　　　　add（t）；　　

　　　　suspend。addActionListener（　　

　　　　　　new　ActionListener（）　｛　　

　　　　　　　　public　　　

　　　　　　　　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　　　　　ss。fauxSuspend（）；　　

　　　　　　　　｝　　

　　　　　　｝）；　　

　　　　add（suspend）；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　520　


…………………………………………………………Page　522……………………………………………………………

　　　　resume。addActionListener（　　

　　　　　　new　ActionListener（）　｛　　

　　　　　　　　public　　　

　　　　　　　　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　　　　　ss。fauxResume（）；　　

　　　　　　　　｝　　

　　　　　　｝）；　　

　　　　add（resume）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Suspend　applet　=　new　Suspend（）；　　

　　　　Frame　aFrame　=　new　Frame（〃Suspend〃）；　　

　　　　aFrame。addWindowListener（　　

　　　　　　new　WindowAdapter（）　｛　　

　　　　　　　　public　void　windowClosing（WindowEvent　e）｛　　

　　　　　　　　　　System。exit（0）；　　

　　　　　　　　｝　　

　　　　　　｝）；　　

　　　　aFrame。add（applet；　BorderLayout。CENTER）；　　

　　　　aFrame。setSize（300；100）；　　

　　　　applet。init（）；　　

　　　　applet。start（）；　　

　　　　aFrame。setVisible（true）；　　

　　｝　　

｝　///：~　　

　　

Suspendable　中的suspended　（已挂起）标志用于开关“挂起”或者“暂停”状态。为挂起一个线程，只需调　

用fauxSuspend（）将标志设为　true　（真）即可。对标志状态的侦测是在run（）内进行的。就象本章早些时候　

提到的那样，wait（）必须设为“同步”（synchronized），使其能够使用对象锁。在fauxResume（）中，　

suspended　标志被设为　false　（假），并调用notify（）——由于这会在一个“同步”从句中唤醒wait（），所　

以fauxResume（）方法也必须同步，使其能在调用notify（）之前取得对象锁（这样一来，对象锁可由要唤醍的　

那个wait（）使用）。如果遵照本程序展示的样式，可以避免使用wait（）和notify（）　。　　

Thread　的　destroy（）方法根本没有实现；它类似一个根本不能恢复的suspend（），所以会发生与suspend（）一　

样的死锁问题。然而，这一方法没有得到明确的“反对”，也许会在　Java　以后的版本（1。2版以后）实现，　

用于一些可以承受死锁危险的特殊场合。　　

大家可能会奇怪当初为什么要实现这些现在又被“反对”的方法。之所以会出现这种情况，大概是由于　Sun　

公司主要让技术人员来决定对语言的改动，而不是那些市场销售人员。通常，技术人员比搞销售的更能理解　

语言的实质。当初犯下了错误以后，也能较为理智地正视它们。这意味着　Java　能够继续进步，即便这使　

Java　程序员多少感到有些不便。就我自己来说，宁愿面对这些不便之处，也不愿看到语言停滞不前。　　



14。4　优先级　　



线程的优先级（Priority　）告诉调试程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运　

行，调试程序会首先运行具有最高优先级的那个线程。然而，这并不表示优先级较低的线程不会运行（换言　

之，不会因为存在优先级而导致死锁）。若线程的优先级较低，只不过表示它被准许运行的机会小一些而　

已。　　

可用getPriority（）方法读取一个线程的优先级，并用　setPriority（）改变它。在下面这个程序片中，大家会　

发现计数器的计数速度慢了下来，因为它们关联的线程分配了较低的优先级：　　

　　

//：　Counter5。java　　

//　Adjusting　the　priorities　of　threads　　

import　java。awt。*；　　

import　java。awt。event。*；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　521　


…………………………………………………………Page　523……………………………………………………………

import　java。applet。*；　　

　　

class　Ticker2　extends　Thread　｛　　

　　private　Button　　　

　　　　b　=　new　Button（〃Toggle〃）；　　

　　　　incPriority　=　new　Button（〃up〃）；　　

　　　　decPriority　=　new　Button（〃down〃）；　　

　　private　TextField　　　

　　　　t　=　new　TextField（10）；　　

　　　　pr　=　new　TextField（3）；　//　Display　priority　　

　　private　int　count　=　0；　　

　　private　boolean　runFlag　=　true；　　

　　public　Ticker2（Container　c）　｛　　

　　　　b。addActionListener（new　ToggleL（））；　　

　　　　incPriority。addActionListener（new　UpL（））；　　

　　　　decPriority。addActionListener（new　DownL（））；　　

　　　　Panel　p　=　new　Panel（）；　　

　　　　p。add（t）；　　

　　　　p。add（pr）；　　

　　　　p。add（b）；　　

　　　　p。add（incPriority）；　　

　　　　p。add（decPriority）；　　

　　　　c。add（p）；　　

　　｝　　

　　class　ToggleL　implements　ActionListener　｛　　

　　　　public　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　runFlag　=　！runFlag；　　

　　　　｝　　

　　｝　　

　　class　UpL　implements　ActionListener　｛　　

　　　　public　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　int　newPriority　=　getPriority（）　＋　1；　　

　　　　　　if（newPriority　》　Thread。MAX_PRIORITY）　　

　　　　　　　　newPriority　=　Thread。MAX_PRIORITY；　　

　　　　　　setPriority（newPriority）；　　

　　　　｝　　

　　｝　　

　　class　DownL　implements　ActionListener　｛　　

　　　　public　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　int　newPriority　=　getPriority（）　1；　　

　　　　　　if（newPriority　《　Thread。MIN_PRIORITY）　　

　　　　　　　　newPriority　=　Thread。MIN_PRIORITY；　　

　　　　　　setPriority（newPriority）；　　

　　　　｝　　

　　｝　　

　　public　void　run（）　｛　　

　　　　while　（true）　｛　　

　　　　　　if（runFlag）　｛　　

　　　　　　　　t。setText（Integer。toString（count＋＋））；　　

　　　　　　　　pr。setText（　　

　　　　　　　　　　Integer。toString（getPriority（）））；　　

　　　　　　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　522　


…………………………………………………………Page　524……………………………………………………………

　　　　　　yield（）；　　

　　　　｝　　

　　｝　　

｝　　

　　

public　class　Counter5　extends　Applet　｛　　

　　private　Button　　　

　　　　start　=　new　Button（〃Start〃）；　　

　　　　upMax　=　new　Button（〃Inc　Max　Priority〃）；　　

　　　　downMax　=　new　Button（〃Dec　Max　Priority〃）；　　

　　private　boolean　started　=　fal　se；　　

　　private　static　final　int　SIZE　=　10；　　

　　private　Ticker2＇＇　s　=　new　Ticker2＇SIZE＇；　　

　　private　TextField　mp　=　new　TextField（3）；　　

　　public　void　init（）　｛　　

　　　　for（int　i　=　0；　i　《　s。length；　i＋＋）　　

　　　　　　s＇i＇　=　new　Ticker2（this）；　　

　　　　add（new　Label（〃MAX_PRIORITY　=　〃　　

　　　　　　＋　Thread。MAX_PRIORITY））；　　

　　　　add（new　Label（〃MIN_PRIORITY　=　〃　　

　　　　　　＋　Thread。MIN_PRIORITY））；　　

　　　　add（new　Label（〃Group　Max　Priority　=　〃））；　　

　　　　add（mp）；　　　

　　　　add（start）；　　

　　　　add（upMax）；　add（downMax）；　　

　　　　start。addActionListener（new　StartL（））；　　

　　　　upMax。addActionListener（new　UpMaxL（））；　　

　　　　downMax。addActionListener（new　DownMaxL（））；　　

　　　　showMaxPriority（）；　　

　　　　//　Recursively　display　parent　thread　groups：　　

　　　　ThreadGroup　parent　=　　　

　　　　　　s＇0＇。getThreadGroup（）。getParent（）；　　

　　　　while（parent　！=　null）　｛　　

　　　　　　add（new　Label（　　

　　　　　　　　〃Parent　threadgroup　max　priority　=　〃　　

　　　　　　　　＋　parent。getMaxPriority（）））；　　

　　　　　　parent　=　parent。getParent（）；　　

　　　　｝　　

　　｝　　

　　public　void　showMaxPriority（）　｛　　

　　　　mp。setText（Integer。toString（　　

　　　　　　s＇0＇。getThreadGroup（）。getMaxPriority（）））；　　

　　｝　　

　　class　StartL　implements　ActionListener　｛　　

　　　　public　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　if（！started）　｛　　

　　　　　　　　started　=　true；　　

　　　　　　　　for（int　i　=　0；　i　《　s。length；　i＋＋）　　

　　　　　　　　　　s＇i＇。start（）；　　

　　　　　　｝　　

　　　　｝　　

　　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　523　


…………………………………………………………Page　525……………………………………………………………

　　class　UpMaxL　implements　ActionListener　｛　　

　　　　public　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　int　maxp　=　　　

　　　　　　　　s＇0＇。getThreadGroup（）。getMaxPriority（）；　　

　　　　　　if（＋＋maxp　》　Thread。MAX_PRIORITY）　　

　　　　　　　　maxp　=　Thread。MAX_PRIORITY；　　

　　　　　　s＇0＇。getThreadGroup（）。setMaxPriority（maxp）；　　

　　　　　　showMaxPriority（）；　　

　　　　｝　　

　　｝　　

　　class　DownMaxL　implements　ActionListener　｛　　

　　　　public　void　actionPerformed（ActionEvent　e）　｛　　

　　　　　　int　maxp　=　　　

　　　　　　　　s＇0＇。getThreadGroup（）。getMaxPriority（）；　　

　　　　　　if（……maxp　《　Thread。MIN_PRIORITY）　　

　　　　　　　　maxp　=　Thread。MIN_PRIORITY；　　

　　　　　　s＇0＇。getThreadGroup（）。setMaxPriority（maxp）；　　

　　　　　　showMaxPriority（）；　　

　　　　｝　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Counter5　applet　=　new　Counter5（）；　　

　　　　Frame　aFrame　=　new　Frame（〃Counter5〃）；　　

　　　　aFrame。addWindowListener（　　

　　　　　　new　WindowAdapter（）　｛　　

　　　　　　　　public　void　windowClosing（WindowEvent　e）　｛　　

　　　　　　　　　　System。exit（0）；　　

　　　　　　　　｝　　

　　　　　　｝）；　　

　　　　aFrame。add（applet；　BorderLayout。CENTER）；　　

　　　　aFrame。setSize（300；　600）；　　

　　　　applet。init（）；　　

　　　　applet。start（）；　　

　　　　aFrame。setVisible（true）；　　

　　｝　　

｝　///：~　　

　　

Ticker　采用本章前面构造好的形式，但有一个额外的　TextField　（文本字段），用于显示线程的优先级；以　

及两个额外的按钮，用于人为提高及降低优先级。　　

也要注意yield（）的用法，它将控制权自动返回给调试程序（机制）。若不进行这样的处理，多线程机制仍　

会工作，但我们会发现它的运行速度慢了下来（试试删去对yield（）的调用）。亦可调用sleep（），但假若那　

样做，计数频率就会改由　sleep（）的持续时间控制，而不是优先级。　　

Counter5　中的init（）创建了由　10个　Ticker2　构成的一个数组；它们的按钮以及输入字段（文本字段）由　

Ticker2　构建器置入窗体。Counter5　增加了新的按钮，用于启动一切，以及用于提高和降低线程组的最大优　

先级。除此以外，还有一些标签用于显示一个线程可以采用的最大及最小优先级；以及一个特殊的文本字　

段，用于显示线程组的最大优先级（在下一节里，我们将全面讨论线程组的问题）。最后，父线程组的优先