对一种非凡的资源——工具中的内存——Java提供了内建的机制来防备它们的斗嘴。由于我们凡是将数据元素设为从属于private(私有)类,然后只通过要了解见那些内存,所以只需将一个特定的要领设为synchronized(同步的),便可有效地防备斗嘴。在任何时刻,只可有一个线程挪用特定工具的一个synchronized要领(尽量谁人线程可以挪用多个工具的同步要领)。下面列出简朴的synchronized要领:
synchronized void f() { /* … */ }
synchronized void g() { /* … */ }
每个工具都包括了一把锁(也叫作“监督器”),它自动成为工具的一部门(不必为此写任何非凡的代码)。挪用任何synchronized要领时,工具就会被锁定,不行再挪用谁人工具的其他任何synchronized要领,除非第一个要领完成了本身的事情,并清除锁定。在上面的例子中,假如为一个工具挪用f(),便不能再为同样的工具挪用g(),除非f()完成并清除锁定。因此,一个特定工具的所有synchronized要领都共享着一把锁,并且这把锁能防备多个要领对通用内存同时举办写操纵(好比同时有多个线程)。
每个类也有本身的一把锁(作为类的Class工具的一部门),所以synchronized static要领可在一个类的范畴内被彼此间锁定起来,防备与static数据的打仗。
留意假如想掩护其他某些资源不被多个线程同时会见,可以强制通过synchronized方会见那些资源。
1. 计数器的同步
装备了这个新要害字后,我们可以或许采纳的方案就更机动了:可以只为TwoCounter中的要领简朴地利用synchronized要害字。下面这个例子是对前例的改版,个中插手了新的要害字:
//: Sharing2.java
// Using the synchronized keyword to prevent
// multiple access to a particular resource.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
class TwoCounter2 extends Thread {
private boolean started = false;
private TextField
t1 = new TextField(5),
t2 = new TextField(5);
private Label l =
new Label("count1 == count2");
private int count1 = 0, count2 = 0;
public TwoCounter2(Container c) {
Panel p = new Panel();
p.add(t1);
p.add(t2);
p.add(l);
c.add(p);
}
public void start() {
if(!started) {
started = true;
super.start();
}
}
public synchronized void run() {
while (true) {
t1.setText(Integer.toString(count1++));
t2.setText(Integer.toString(count2++));
try {
sleep(500);
} catch (InterruptedException e){}
}
}
public synchronized void synchTest() {
Sharing2.incrementAccess();
if(count1 != count2)
l.setText("Unsynched");
}
}
class Watcher2 extends Thread {
private Sharing2 p;
public Watcher2(Sharing2 p) {
this.p = p;
start();
}
public void run() {
while(true) {
for(int i = 0; i < p.s.length; i++)
p.s[i].synchTest();
try {
sleep(500);
} catch (InterruptedException e){}
}
}
}
public class Sharing2 extends Applet {
TwoCounter2[] s;
private static int accessCount = 0;
private static TextField aCount =
new TextField("0", 10);
public static void incrementAccess() {
accessCount++;
aCount.setText(Integer.toString(accessCount));
}
private Button
start = new Button("Start"),
observer = new Button("Observe");
private boolean isApplet = true;
private int numCounters = 0;
private int numObservers = 0;
public void init() {
if(isApplet) {
numCounters =
Integer.parseInt(getParameter("size"));
numObservers =
Integer.parseInt(
getParameter("observers"));
}
s = new TwoCounter2[numCounters];
for(int i = 0; i < s.length; i++)
s[i] = new TwoCounter2(this);
Panel p = new Panel();
start.addActionListener(new StartL());
p.add(start);
observer.addActionListener(new ObserverL());
p.add(observer);
p.add(new Label("Access Count"));
p.add(aCount);
add(p);
}
class StartL implements ActionListener {
public void actionPerformed(ActionEvent e) {
for(int i = 0; i < s.length; i++)
s[i].start();
}
}
class ObserverL implements ActionListener {
public void actionPerformed(ActionEvent e) {
for(int i = 0; i < numObservers; i++)
new Watcher2(Sharing2.this);
}
}
public static void main(String[] args) {
Sharing2 applet = new Sharing2();
// This isn't an applet, so set the flag and
// produce the parameter values from args:
applet.isApplet = false;
applet.numCounters =
(args.length == 0 ? 5 :
Integer.parseInt(args[0]));
applet.numObservers =
(args.length < 2 ? 5 :
Integer.parseInt(args[1]));
Frame aFrame = new Frame("Sharing2");
aFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(350, applet.numCounters *100);
applet.init();
applet.start();
aFrame.setVisible(true);
}
} ///:~
#p#分页标题#e#
我们留意到无论run()照旧synchTest()都是“同步的”。假如只同步个中的一个要领,那么另一个就可以自由忽视工具的锁定,并可无碍地挪用。所以必需记着一个重要的法则:对付会见某个要害共享资源的所有要领,都必需把它们设为synchronized,不然就不能正常地事情。
此刻又碰着了一个新问题。Watcher2永远都不能看到正在举办的工作,因为整个run()要领已设为“同步”。并且由于必定要为每个工具运行run(),所以锁永远不能打开,而synchTest()永远不会获得挪用。之所以能看到这一功效,是因为accessCount基础没有变革。
为办理这个问题,我们能采纳的一个步伐是只将run()中的一部门代码断绝出来。想用这个步伐断绝出来的那部门代码叫作“要害区域”,并且要用差异的方法来利用synchronized要害字,以配置一个要害区域。Java通过“同步块”提供对要害区域的支持;这一次,我们用synchronized要害字指出工具的锁用于对个中关闭的代码举办同步。如下所示:
synchronized(syncObject) {
// This code can be accessed by only
// 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要害字。
