程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> Java多線程同步問題的探究(二、給我一把鎖,我能創造一個規矩)

Java多線程同步問題的探究(二、給我一把鎖,我能創造一個規矩)

編輯:關於JAVA

在上一篇中,我們講到了多線程是如何處理共享資源的,以及保證他們對資源進行互斥訪問所依賴的重要機制:對象鎖。

本篇中,我們來看一看傳統的同步實現方式以及這背後的原理。

很多人都知道,在Java多線程編程中,有一個重要的關鍵字,synchronized。但是很多人看到這個東西會感到困惑:“都說同步機制是 通過對象鎖來實現的,但是這麼一個關鍵字,我也看不出來Java程序鎖住了哪個對象阿?“

沒錯,我一開始也是對這個問題感到困惑和不解。不過還好,我們有下面的這個例程:

1 public class ThreadTest extends Thread {
2
3     private int threadNo;
4
5      public ThreadTest(int threadNo) {
6         this.threadNo = threadNo;
7     }
8
9      public static void main(String[] args) throws Exception {
10         for (int i = 1; i <  10; i++) {
11             new ThreadTest(i).start();
12             Thread.sleep (1);
13         }
14     }
15
16     @Override
17     public synchronized void  run() {
18         for (int i = 1; i < 10000; i++) {
19              System.out.println("No." + threadNo + ":" + i);
20         }
21     }
22 }

這個程序其實就是讓10個線程在控制台上數數,從1數到9999。理想情況下,我們希望看到一個線程數完,然後才是另一個線程開始數 數。但是這個程序的執行過程告訴我們,這些線程還是亂糟糟的在那裡搶著報數,絲毫沒有任何規矩可言。

但是細心的讀者注意到:run方法還是加了一個synchronized關鍵字的,按道理說,這些線程應該可以一個接一個的執行這個run方法才 對阿。

但是通過上一篇中,我們提到的,對於一個成員方法加synchronized關鍵字,這實際上是以這個成員方法所在的對象本身作為對象鎖。 在本例中,就是以ThreadTest類的一個具體對象,也就是該線程自身作為對象鎖的。一共十個線程,每個線程持有自己線程對象的那個對 象鎖。這必然不能產生同步的效果。換句話說,如果要對這些線程進行同步,那麼這些線程所持有的對象鎖應當是共享且唯一的!

我們來看下面的例程:

1 public class ThreadTest2 extends Thread {
2
3     private int threadNo;
4      private String lock;
5
6     public ThreadTest2(int threadNo, String lock) {
7          this.threadNo = threadNo;
8         this.lock = lock;
9     }
10
11     public static  void main(String[] args) throws Exception {
12         String lock = new String("lock");
13          for (int i = 1; i < 10; i++) {
14             new ThreadTest2(i, lock).start ();
15             Thread.sleep(1);
16         }
17     }
18
19     public  void run() {
20         synchronized (lock) {
21             for (int i = 1; i  < 10000; i++) {
22                 System.out.println("No." + threadNo + ":" + i);
23              }
24         }
25     }
26 }

我們注意到,該程序通過在main方法啟動10個線程之前,創建了一個String類型的對象。並通過ThreadTest2的構造函數,將這個對象 賦值給每一個ThreadTest2線程對象中的私有變量lock。根據Java方法的傳值特點,我們知道,這些線程的lock變量實際上指向的是堆內存 中的同一個區域,即存放main函數中的lock變量的區域。

程序將原來run方法前的synchronized關鍵字去掉,換用了run方法中的一個synchronized塊來實現。這個同步塊的對象鎖,就是 main 方法中創建的那個String對象。換句話說,他們指向的是同一個String類型的對象,對象鎖是共享且唯一的!

於是,我們看到了預期的效果:10個線程不再是爭先恐後的報數了,而是一個接一個的報數。

再來看下面的例程:

1 public class ThreadTest3 extends Thread {
2
3     private int threadNo;
4      private String lock;
5
6     public ThreadTest3(int threadNo) {
7         this.threadNo =  threadNo;
8     }
9
10     public static void main(String[] args) throws Exception {
11          //String lock = new String("lock");
12         for (int i = 1; i < 20; i++)  {
13             new ThreadTest3(i).start();
14             Thread.sleep(1);
15          }
16     }
17
18     public static synchronized void abc(int threadNo) {
19          for (int i = 1; i < 10000; i++) {
20
21                  System.out.println("No." + threadNo + ":" + i);
22
23
24
25
26         }
27     }
28
29     public void run() {
30         abc(threadNo);
31     }
32 }

細心的讀者發現了:這段代碼沒有使用main方法中創建的String對象作為這10個線程的線程鎖。而是通過在run方法中調用本線程中一 個靜態的同步方法abc而實現了線程的同步。我想看到這裡,你們應該很困惑:這裡synchronized靜態方法是用什麼來做對象鎖的呢?

我們知道,對於同步靜態方法,對象鎖就是該靜態放發所在的類的Class實例,由於在JVM中,所有被加載的類都有唯一的類對象,具體 到本例,就是唯一的ThreadTest3.class對象。不管我們創建了該類的多少實例,但是它的類實例仍然是一個!

這樣我們就知道了:

1、對於同步的方法或者代碼塊來說,必須獲得對象鎖才能夠進入同步方法或者代碼塊進行操作;

2、如果采用method級別的同步,則對象鎖即為method所在的對象,如果是靜態方法,對象鎖即指method所在的

Class對象(唯一);

3、對於代碼塊,對象鎖即指synchronized(abc)中的abc;

4、因為第一種情況,對象鎖即為每一個線程對象,因此有多個,所以同步失效,第二種共用同一個對象鎖lock,因此同步生效,第三 個因為是

static因此對象鎖為ThreadTest3的class 對象,因此同步生效。

如上述正確,則同步有兩種方式,同步塊和同步方法(為什麼沒有wait和notify?這個我會在補充章節中做出闡述)

如果是同步代碼塊,則對象鎖需要編程人員自己指定,一般有些代碼為synchronized(this)只有在單態模式才生效;

(本類的實例有且只有一個)

如果是同步方法,則分靜態和非靜態兩種。

靜態方法則一定會同步,非靜態方法需在單例模式才生效,推薦用靜態方法(不用擔心是否單例)。

所以說,在Java多線程編程中,最常見的synchronized關鍵字實際上是依靠對象鎖的機制來實現線程同步的。

我們似乎可以聽到synchronized在向我們說:“給我一把鎖,我能創造一個規矩”。

下一篇中,我們將看到JDK 5提供的新的同步機制,也就是大名鼎鼎的Doug Lee提供的Java Concurrency框架。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved