Java编程思想第4版[中文版](PDF格式)-第131部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
Java 通过“同步块”提供对关键区域的支持；这一次，我们用 synchronized关键字指出对象的锁用于对其
中封闭的代码进行同步。如下所示：
synchronized（syncObject） ｛
// This code can be accessed by on ly
// one thread at a time； assuming all
// threads respect syncObject's lock
｝
在能进入同步块之前，必须在 synchObject 上取得锁。如果已有其他线程取得了这把锁，块便不能进入，必
须等候那把锁被释放。
可从整个run（）中删除 synchronized关键字，换成用一个同步块包围两个关键行，从而完成对 Sharing2 例
子的修改。但什么对象应作为锁来使用呢？那个对象已由 synchTest（）标记出来了——也就是当前对象
（this）！所以修改过的run（）方法象下面这个样子：
public void run（） ｛
while （true） ｛
synchronized（this） ｛
t1。setText（Integer。toString（count1＋＋））；
t2。setText（Integer。toString（count2＋＋））；
｝
try ｛
sleep（500）；
｝ catch （InterruptedException e）｛｝
｝
｝
这是必须对 Sharing2。java 作出的唯一修改，我们会看到尽管两个计数器永远不会脱离同步（取决于允许
Watcher 什么时候检查它们），但在run（）执行期间，仍然向 Watcher 提供了足够的访问权限。
当然，所有同步都取决于程序员是否勤奋：要访问共享资源的每一部分代码都必须封装到一个适当的同步块
里。
2。 同步的效率
由于要为同样的数据编写两个方法，所以无论如何都不会给人留下效率很高的印象。看来似乎更好的一种做
法是将所有方法都设为自动同步，并完全消除 synchronized关键字（当然，含有synchronized run（）的例
子显示出这样做是很不通的）。但它也揭示出获取一把锁并非一种“廉价”方案——为一次方法调用付出的
代价（进入和退出方法，不执行方法主体）至少要累加到四倍，而且根据我们的具体现方案，这一代价还有
可能变得更高。所以假如已知一个方法不会造成冲突，最明智的做法便是撤消其中的 synchronized关键字。
14。2。3 回顾 Java Beans
我们现在已理解了同步，接着可换从另一个角度来考察Java Beans。无论什么时候创建了一个Bean ，就必须
假定它要在一个多线程的环境中运行。这意味着：
506
…………………………………………………………Page 508……………………………………………………………
（1） 只要可行，Bean 的所有公共方法都应同步。当然，这也带来了“同步”在运行期间的开销。若特别在意
这个问题，在关键区域中不会造成问题的方法就可保留为“不同步”，但注意这通常都不是十分容易判断。
有资格的方法倾向于规模很小（如下例的 getCircleSize（））以及／或者“微小”。也就是说，这个方法调
用在如此少的代码片里执行，以至于在执行期间对象不能改变。如果将这种方法设为“不同步”，可能对程
序的执行速度不会有明显的影响。可能也将一个Bean 的所有public 方法都设为 synchronized，并只有在保
证特别必要、而且会造成一个差异的情况下，才将 synchronized关键字删去。
（2） 如果将一个多造型事件送给一系列对那个事件感兴趣的“听众”，必须假在列表中移动的时候可以添加
或者删除。
第一点很容易处理，但第二点需要考虑更多的东西。让我们以前一章提供的BangBean。java 为例。在那个例
子中，我们忽略了 synchronized 关键字（那时还没有引入呢），并将造型设为单造型，从而回避了多线程的
问题。在下面这个修改过的版本中，我们使其能在多线程环境中工作，并为事件采用了多造型技术：
//： BangBean2。java
// You should write your Beans this way so they
// can run in a multithreaded environment。
import java。awt。*；
import java。awt。event。*；
import java。util。*；
import java。io。*；
public class BangBean2 extends Canvas
implements Serializable ｛
private int xm； ym；
private int cSize = 20； // Circle size
private String text = 〃Bang！〃；
private int fontSize = 48；
private Color tColor = Color。red；
private Vector actionListeners = new Vector（）；
public BangBean2（） ｛
addMouseListener（new ML（））；
addMouseMotionListener（new MM（））；
｝
public synchronized int getCircleSize（） ｛
return cSize；
｝
public synchronized void
setCircleSize（int newSize） ｛
cSize = newSize；
｝
public synchronized String getBangText（） ｛
return text；
｝
public synchronized void
setBangText（String newText） ｛
text = newText；
｝
public synchronized int getFontSize（） ｛
return fontSize；
｝
public synchronized void
setFontSize（int newSize） ｛
507
…………………………………………………………Page 509……………………………………………………………
fontSize = newSize；
｝
public synchronized Color getTextColor（） ｛
return tColor；
｝
public synchronized void
setTextColor（Color newColor） ｛
tColor = newColor；
｝
public void paint（Graphics g） ｛
g。setColor（Color。black）；
g。drawOval（xm cSize/2； ym cSize/2；
cSize； cSize）；
｝
// This is a multicast listener； which is
// more typically used than the unicast
// approach taken in BangBean。java：
public synchronized void addActionListener （
ActionListener l） ｛
actionListeners。addElement（l）；
｝
public synchronized void removeActionListener（
ActionListener l） ｛
actionListeners。removeElement（l）；
｝
// Notice this isn't synchronized：
public void notifyListeners（） ｛
ActionEvent a =
new ActionEvent（BangBean2。this；
ActionEvent。ACTION_PERFORMED； null）；
Vector lv = null；
// Make a copy of the vector in case someone
// adds a listener while we're
// calling listeners：
synchronized（this） ｛
lv = （Vector）actionListeners。clone（）；
｝
// Call all the listener methods：
for（int i = 0； i 《 lv。size（）； i＋＋） ｛
ActionListener al =
（ActionListener）lv。elementAt（i）；
al。actionPerformed（a）；
｝
｝
class ML extends MouseAdapter ｛
public void mousePressed（MouseEvent e） ｛
Graphics g = getGraphics（）；
g。setColor（tColor）；
g。setFont（
new Font（
〃TimesRoman〃； Font。BOLD； fontSize））；
int width =
508
…………………………………………………………Page 510……………………………………………………………
g。getFontMetrics（）。stringWidth（text）；
g。drawString（text；
（getSize（）。width width） /2；
getSize（）。height/2）；
g。dispose（）；
notifyListeners（）；
｝
｝
class MM extends MouseMotionAdapter ｛
public void mouseMoved（MouseEvent e） ｛
xm = e。getX（）；
ym = e。getY（）；
repaint（）；
｝
｝
// Testing the BangBean2：
public static void main（String＇＇ args） ｛
BangBean2 bb = new BangBean2（）；
bb。addActionListener（new ActionListener（） ｛
public void actionPerformed（ActionEvent e）｛
System。out。println（〃ActionEvent〃 ＋ e）；
｝
｝）；
bb。addActionListener（new ActionListener（） ｛
public void actionPerformed（ActionEvent e）｛
System。out。println（〃BangBean2 action〃）；
｝
｝）；
bb。addActionListener（new ActionListener（） ｛
public void actionPerformed（ActionEvent e）｛
System。out。println（〃More action〃）；
｝
｝）；
Frame aFrame = new Frame（〃BangBean2 Test〃）；
aFrame。addWindowListener（new WindowAdapter（）｛
public void windowClosing（WindowEvent e） ｛
System。exit（0）；
｝
｝）；
aFrame。add（bb； BorderLayout。CENTER）；
aFrame。setSize（300；300）；
aFrame。setVisible（true）；
｝
｝ ///：~
很容易就可以为方法添加synchronized。但注意在addActionListener（）和 removeActionListener（）中，现
在添加了ActionListener，并从一个 Vector 中移去，所以能够根据自己愿望使用任意多个。
我们注意到，notifyListeners（）方法并未设为“同步”。可从多个线程中发出对这个方法的调用。另外，在
对notifyListeners（）调用的中途，也可能发出对addActionListener（）和 removeActionListener（） 的调
用。这显然会造成问题，因为它否定了Vector actionListeners 。为缓解这个问题，我们在一个
synchronized从句中“克隆”了 Vector，并对克隆进行了否定。这样便可在不影响notifyListeners（）的前
提下，对Vector 进行操纵。
509
…………………………………………………………Page 511……………………………………………………………
paint（）方法也没有设为“同步”。与单纯地添加自己的方法相比，决定是否对过载的方法进行同步要困难得
多。在这个例子中，无论paint（）是否“同步”，它似乎都能正常地工作。但必须考虑的问题包括：
（1） 方法会在对象内部修改“关键”变量的状态吗？为判断一个变量是否“关键”，必须知道它是否会被程
序中的其他线程读取或设置（就目前的情况看，读取或设置几乎肯定是通过“同步”方法进行的，所以可以
只对它们进行检查）。对paint（）的情况来说，不会发生任何修改。
（2） 方法要以这些“关键”变量的状态为基础吗？如果一个“同步”方法修改了一个变量，而我们的方法要
用到这个变量，那么一般都愿意把自己的方法也设为“同步”。基于这一前提，大家可观察到cSize 由“同
步”方法进行了修改，所以paint（）应当是“同步”的。但在这里，我们可以问：“假如 cSize 在paint（）执
行期间发生了变化，会发生的最糟糕的事情是什么呢？”如果发现情况不算太坏，而且仅仅是暂时的效果，
那么最好保持paint（）的“不同步”状态，以避免同步方法调用带来的额外开销。
（3） 要留意的第三条线索是 paint（）基础类版本是否“同步”，在这里它不是同步的。这并不是一个非常严
格的参数，仅仅是一条“线索”。比如在目前的情况下，通过同步方法（好cSize）改变的一个字段已合成
到paint（）公式里，而且可能已改变了情况。但请注意，synchronized不能继承——也就是说，假如一个方
法在基础类中是“同步”的，那么在衍生类过载版本中，它不会自动进入“同步”状态。
TestBangBean2 中的测试代码已在前一章的基础上进行了修改，已在其中加入了额外的“听众”，从而演示
了BangBean2 的多造型能力。
14。3 堵塞
一个线程可以有四种状态：
（1） 新（New）：线程对象已经创建，但尚未启动，所以不可运行。
（2） 可运行（Runnable ）：意味着一旦时间分片机制有空闲的CPU 周期提供给一个线程，那个线程便可立即
开始运行。因此，线程可能在、也可能不在运行当中�
