共享有限的資源

2019-11-18 13:23:01

字體：大中小

來源：轉載

供稿：網友

　　共享有限的資源
　　可將單線程程序想象成一種孤立的實體，它能遍歷我們的問題空間，而且一次只能做一件事情。由于只有一個實體，所以永遠不必擔心會有兩個實體同時試圖使用相同的資源，就象兩個人同時都想停到一個車位，同時都想通過一扇門，甚至同時發話。
　　進入多線程環境后，它們則再也不是孤立的。可能會有兩個甚至更多的線程試圖同時同一個有限的資源。必須對這種潛在資源沖突進行預防，否則就可能發生兩個線程同時訪問一個銀行帳號，打印到同一臺計算機，以及對同一個值進行調整等等。
　　1 資源訪問的錯誤方法
　　現在考慮換成另一種方式來使用本章頻繁見到的計數器。在下面的例子中，每個線程都包含了兩個計數器，它們在run()里增值以及顯示。除此以外，我們使用了Watcher類的另一個線程。它的作用是監視計數器，檢查它們是否保持相等。這表面是一項無意義的行動，因為假如查看代碼，就會發現計數器肯定是相同的。但實際情況卻不一定如此。下面是程序的第一個版本：
　　//: Sharing1.java
　　// PRoblems with resource sharing while threading
　　import java.awt.*;
　　import java.awt.event.*;
　　import java.applet.*;
　　class TwoCounter 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;
　　　// Add the display components as a panel
　　　// to the given container:
　　　public TwoCounter(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 void run() {
　　　　while (true) {
　　　　　t1.setText(Integer.toString(count1++));
　　　　　t2.setText(Integer.toString(count2++));
　　　　　try {
　　　　　　sleep(500);
　　　　　} catch (InterruptedException e){}
　　　　}
　　　}
　　　public void synchTest() {
　　　　Sharing1.increment access();
　　　　if(count1 != count2)
　　　　　l.setText("Unsynched");
　　　}
　　}
　　class Watcher extends Thread {
　　　private Sharing1 p;
　　　public Watcher(Sharing1 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 Sharing1 extends Applet {
　　　TwoCounter[] 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 TwoCounter[numCounters];
　　　　for(int i = 0; i < s.length; i++)
　　　　　s[i] = new TwoCounter(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 Watcher(Sharing1.this);
　　　　}
　　　}
　　　public static void main(String[] args) {
　　　　Sharing1 applet = new Sharing1();
　　　　// 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("Sharing1");
　　　　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);
　　　}
　　}
　　和往常一樣，每個計數器都包含了自己的顯示組件：兩個文本字段以及一個標簽。根據它們的初始值，可知道計數是相同的。這些組件在TwoCounter構建器加入Container。由于這個線程是通過用戶的一個“按下按鈕”操作啟動的，所以start()可能被多次調用。但對一個線程來說，對Thread.start()的多次調用是非法的（會產生違例）。在started標記和過載的start()方法中，大家可看到針對這一情況采取的防范措施。
　　在run()中，count1和count2的增值與顯示方式表面上似乎能保持它們完全一致。隨后會調用sleep()；若沒有這個調用，程序便會出錯，因為那會造成CPU難于交換任務。
　　synchTest()方法采取的似乎是沒有意義的行動，它檢查count1是否等于count2；假如不等，就把標簽設為“Unsynched”（不同步）。但是首先，它調用的是類Sharing1的一個靜態成員，以便增值和顯示一個訪問計數器，指出這種檢查已成功進行了多少次（這樣做的理由會在本例的其他版本中變得非常明顯）。
　　Watcher類是一個線程，它的作用是為處于活動狀態的所有TwoCounter對象都調用synchTest()。其間，它會對Sharing1對象中容納的數組進行遍歷。可將Watcher想象成它擦過TwoCounter對象的肩膀不斷地“偷看”。
　　Sharing1包含了TwoCounter對象的一個數組，它通過init()進行初始化，并在我們按下“start”按鈕后作為線程啟動。以后若按下“Observe”（觀察）按鈕，就會創建一個或者多個觀察器，并對毫不設防的TwoCounter進行調查。
　　注重為了讓它作為一個程序片在瀏覽器中運行，Web頁需要包含下面這幾行：
　　<applet code=Sharing1 width=650 height=500>

　　<param name=size value="20">

　　<param name=observers value="1">

　　</applet>
　　可自行改變寬度、高度以及參數，根據自己的意愿進行試驗。若改變了size和observers，程序的行為也會發生變化。我們也注重到，通過從命令行接受參數（或者使用默認值），它被設計成作為一個獨立的應用程序運行。
　　下面才是最讓人“不可思議”的。在TwoCounter.run()中，無限循環只是不斷地重復相鄰的行：
　　t1.setText(Integer.toString(count1++));
　　t2.setText(Integer.toString(count2++));
　　（和“睡眠”一樣，不過在這里并不重要）。但在程序運行的時候，你會發現count1和count2被“觀察”（用Watcher觀察）的次數是不相等的！這是由線程的本質造成的——它們可在任何時候掛起（暫停）。所以在上述兩行的執行時刻之間，有時會出現執行暫停現象。同時，Watcher線程也正好跟隨著進來，并正好在這個時候進行比較，造成計數器出現不相等的情況。
　　本例揭示了使用線程時一個非常基本的問題。我們跟無從知道一個線程什么時候運行。想象自己坐在一張桌子前面，桌上放有一把叉子，預備叉起自己的最后一塊食物。當叉子要碰到食物時，食物卻忽然消失了（因為這個線程已被掛起，同時另一個線程進來“偷”走了食物）。這便是我們要解決的問題。
　　有的時候，我們并不介意一個資源在嘗試使用它的時候是否正被訪問（食物在另一些盤子里）。但為了讓多線程機制能夠正常運轉，需要采取一些措施來防止兩個線程訪問相同的資源——至少在要害的時期。
　　為防止出現這樣的沖突，只需在線程使用一個資源時為其加鎖即可。訪問資源的第一個線程會其加上鎖以后，其他線程便

上一篇：違例控制：解決錯誤

下一篇：反應靈敏的用戶界面