<ruby id="bdb3f"></ruby>

    <p id="bdb3f"><cite id="bdb3f"></cite></p>

      <p id="bdb3f"><cite id="bdb3f"><th id="bdb3f"></th></cite></p><p id="bdb3f"></p>
        <p id="bdb3f"><cite id="bdb3f"></cite></p>

          <pre id="bdb3f"></pre>
          <pre id="bdb3f"><del id="bdb3f"><thead id="bdb3f"></thead></del></pre>

          <ruby id="bdb3f"><mark id="bdb3f"></mark></ruby><ruby id="bdb3f"></ruby>
          <pre id="bdb3f"><pre id="bdb3f"><mark id="bdb3f"></mark></pre></pre><output id="bdb3f"></output><p id="bdb3f"></p><p id="bdb3f"></p>

          <pre id="bdb3f"><del id="bdb3f"><progress id="bdb3f"></progress></del></pre>

                <ruby id="bdb3f"></ruby>

                ??碼云GVP開源項目 12k star Uniapp+ElementUI 功能強大 支持多語言、二開方便! 廣告
                # 14.2 共享有限的資源 可將單線程程序想象成一種孤立的實體,它能遍歷我們的問題空間,而且一次只能做一件事情。由于只有一個實體,所以永遠不必擔心會有兩個實體同時試圖使用相同的資源,就象兩個人同時都想停到一個車位,同時都想通過一扇門,甚至同時發話。 進入多線程環境后,它們則再也不是孤立的。可能會有兩個甚至更多的線程試圖同時同一個有限的資源。必須對這種潛在資源沖突進行預防,否則就可能發生兩個線程同時訪問一個銀行帳號,打印到同一臺計算機,以及對同一個值進行調整等等。 ## 14.2.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.incrementAccess(); 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`線程也正好跟隨著進來,并正好在這個時候進行比較,造成計數器出現不相等的情況。 本例揭示了使用線程時一個非常基本的問題。我們跟無從知道一個線程什么時候運行。想象自己坐在一張桌子前面,桌上放有一把叉子,準備叉起自己的最后一塊食物。當叉子要碰到食物時,食物卻突然消失了(因為這個線程已被掛起,同時另一個線程進來“偷”走了食物)。這便是我們要解決的問題。 有的時候,我們并不介意一個資源在嘗試使用它的時候是否正被訪問(食物在另一些盤子里)。但為了讓多線程機制能夠正常運轉,需要采取一些措施來防止兩個線程訪問相同的資源——至少在關鍵的時期。 為防止出現這樣的沖突,只需在線程使用一個資源時為其加鎖即可。訪問資源的第一個線程會其加上鎖以后,其他線程便不能再使用那個資源,除非被解鎖。如果車子的前座是有限的資源,高喊“這是我的!”的孩子會主張把它鎖起來。 ## 14.2.2 Java如何共享資源 對一種特殊的資源——對象中的內存——Java提供了內建的機制來防止它們的沖突。由于我們通常將數據元素設為從屬于`private`(私有)類,然后只通過方法訪問那些內存,所以只需將一個特定的方法設為`synchronized`(同步的),便可有效地防止沖突。在任何時刻,只可有一個線程調用特定對象的一個`synchronized`方法(盡管那個線程可以調用多個對象的同步方法)。下面列出簡單的s`ynchronized`方法: ``` 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); } } ///:~ ``` 我們注意到無論`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`關鍵字。 ## 14.2.3 回顧Java Beans 我們現在已理解了同步,接著可換從另一個角度來考察Java Beans。無論什么時候創建了一個Bean,就必須假定它要在一個多線程的環境中運行。這意味著: (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) { 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 = 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`進行操縱。 `paint()`方法也沒有設為“同步”。與單純地添加自己的方法相比,決定是否對重載的方法進行同步要困難得多。在這個例子中,無論`paint()`是否“同步”,它似乎都能正常地工作。但必須考慮的問題包括: (1) 方法會在對象內部修改“關鍵”變量的狀態嗎?為判斷一個變量是否“關鍵”,必須知道它是否會被程序中的其他線程讀取或設置(就目前的情況看,讀取或設置幾乎肯定是通過“同步”方法進行的,所以可以只對它們進行檢查)。對`paint()`的情況來說,不會發生任何修改。 (2) 方法要以這些“關鍵”變量的狀態為基礎嗎?如果一個“同步”方法修改了一個變量,而我們的方法要用到這個變量,那么一般都愿意把自己的方法也設為“同步”。基于這一前提,大家可觀察到`cSize`由“同步”方法進行了修改,所以`paint()`應當是“同步”的。但在這里,我們可以問:“假如`cSize`在`paint()`執行期間發生了變化,會發生的最糟糕的事情是什么呢?”如果發現情況不算太壞,而且僅僅是暫時的效果,那么最好保持`paint()`的“不同步”狀態,以避免同步方法調用帶來的額外開銷。 (3) 要留意的第三條線索是`paint()`基類版本是否“同步”,在這里它不是同步的。這并不是一個非常嚴格的參數,僅僅是一條“線索”。比如在目前的情況下,通過同步方法(好`cSize`)改變的一個字段已組合到`paint()`公式里,而且可能已改變了情況。但請注意,`synchronized`不能繼承——也就是說,假如一個方法在基類中是“同步”的,那么在派生類重載版本中,它不會自動進入“同步”狀態。 `TestBangBean2`中的測試代碼已在前一章的基礎上進行了修改,已在其中加入了額外的“聽眾”,從而演示了`BangBean2`的多轉換能力。
                  <ruby id="bdb3f"></ruby>

                  <p id="bdb3f"><cite id="bdb3f"></cite></p>

                    <p id="bdb3f"><cite id="bdb3f"><th id="bdb3f"></th></cite></p><p id="bdb3f"></p>
                      <p id="bdb3f"><cite id="bdb3f"></cite></p>

                        <pre id="bdb3f"></pre>
                        <pre id="bdb3f"><del id="bdb3f"><thead id="bdb3f"></thead></del></pre>

                        <ruby id="bdb3f"><mark id="bdb3f"></mark></ruby><ruby id="bdb3f"></ruby>
                        <pre id="bdb3f"><pre id="bdb3f"><mark id="bdb3f"></mark></pre></pre><output id="bdb3f"></output><p id="bdb3f"></p><p id="bdb3f"></p>

                        <pre id="bdb3f"><del id="bdb3f"><progress id="bdb3f"></progress></del></pre>

                              <ruby id="bdb3f"></ruby>

                              哎呀哎呀视频在线观看