搞懂java中的synchronized關鍵字 – JAVA編程語言程序開發技術文章

搞懂java中的synchronized關鍵字:
————————————————————–

實際上,我關於java的基礎知識的90%以上都來自Thinking in Java。對於其中的synchronized關鍵字,
當時就是瀏覽一下,大概知道意思,也沒有細看。後來一直沒有用過這個關鍵字。
昨天看Thinking in Patterns with Java中的Observer模式,
看瞭其中的Observable類的源碼,發現裡面幾乎所有的方法都用瞭synchronized關鍵字(不是全部),
其中個別用瞭synchronized(this){}的區塊。於是,我發覺有必要好好理解一下這個關鍵字瞭。

我再次看瞭侯捷譯的Thinking in Java第二版中文版,得到有關synchronized的如下信息:

1、synchronized關鍵字的作用域有二種:
1) 是某個對象實例內,synchronized aMethod(){}可以防止多個線程同時訪問這個對象的synchronized方法
    (如果一個對象有多個synchronized方法,隻要一個線程訪問瞭其中的一個synchronized方法,其它線程不
    能同時訪問這個對象中任何一個synchronized方法)。這時,不同的對象實例的synchronized方法是不相幹擾的。
    也就是說,其它線程照樣可以同時訪問相同類的另一個對象實例中的synchronized方法;
2) 是某個類的范圍,synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的synchronized static 方法。
    它可以對類的所有對象實例起作用。

2、除瞭方法前用synchronized關鍵字,synchronized關鍵字還可以用於方法中的某個區塊中,表示隻對這個區塊的資源實行互斥訪問。
    用法是: synchronized(this){/*區塊*/},它的作用域是當前對象;
   
3、synchronized關鍵字是不能繼承的,也就是說,基類的方法synchronized f(){} 在繼承類中並不自動是synchronized f(){},
    而是變成瞭f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法;

4、疑問:
    我知道瞭有static區塊(其中的加載時機好像也不清楚,需要學習一下,原來看Thinking in Java好像是說: static區塊加載的時機
    是類的一個對象實例創建或類的一個static方法被訪問,但是我今天早上看瞭javaeye.com上面的一個關於“<static塊到底什麼時候執行?
    -eway -JavaEye技術社區>”的文章後又有點迷糊瞭:),也許,需要認真學習一下JVM的內在機制才是理解這類問題最根本的途徑),
    也有synchronized區塊,那麼,有synchronized static 區塊嗎?意思是問:有沒有一個類作用域內的synchronized區塊?

今天,寫瞭下面這個例子驗證瞭上面有沒有一個類范圍的synchronized 或 synchronized static 塊,結論是沒有這樣的塊。也就是,對整個
類范圍的某塊資源實行synchronized,唯一的方法是用:synchronized static方法,像這樣:synchronized static void ff()
{/*your code here*/} (littlebat後註:2007.2.13, 在朋友V.C的幫助下,終於知道在類的一個方法中,可以存在整個類范圍內的
synchronized區塊,像這樣:        synchronized (TestSynchronized.class) {/*some code*/},詳情見後 )

全部的例子如下,如果我的例子和想法有任何不當的地方,還希望看見的朋友指點一下。謝謝。

例程:  TestSynchronized.java
public class TestSynchronized {
 
    static{
        System.out.println("Step 1: a static block in class scope.");
    }

    static void f(){
        System.out.println("Step 2: a static method f() in class scope.");
    }

    synchronized static void ff(){ //The only way of synchronized a part in class scope.
        System.out.println("Step 3: a synchronized static method ff() in class scope.");
    }

    /*//No any synchronized block in class scope!
    synchronized {
        System.out.println("A synchronized block in class scope.");
    }
    */

    /*//No any synchronized static block in class scope!
    synchronized static {
        System.out.println("A synchronized static block in class scope.");
    }
    */
    
    void fff(){
        synchronized(this){
            System.out.println("Step 4: a synchronized block in method fff() in object scope.");
        }
    }
    
    synchronized void ffff(){
        System.out.println("Step 5: a synchronized method ffff() in object scope.");
    }
    
    public static void main(String[] args) {

        TestSynchronized.f();
        TestSynchronized.ff();
        (new TestSynchronized()).fff();
        (new TestSynchronized()).ffff();

    }

}

運行結果:
Step 1: a static block in class scope.
Step 2: a static method f() in class scope.
Step 3: a synchronized static method ff() in class scope.
Step 4: a synchronized block in method fff() in object scope.
Step 5: a synchronized method ffff() in object scope.

The format below can implement synchronizing in Class scope:

synchronized (TestSynchronized.Class) {
}

Yes, I can get synchronized block in a method in class scope
(Note: TestSynchronized.class isn't TestSynchronized.Class):

void fffff(){
        synchronized (TestSynchronized.class) {
            System.out.println("Step 6: a synchronized block in method fffff() in class scope.");
        }
    }
   
 
————————————————  
對synchronized(this)的一些理解  :
————————————————  
synchronized 關鍵字,它包括兩種用法:synchronized 方法和 synchronized 塊。
1. synchronized 方法

通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如:
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變量的訪問:每個類實例對應一把鎖,每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行,
否則所屬線程阻塞,方法一旦執行,就獨占該鎖,直到從該方法返回時才將鎖釋放,此後被阻塞的線程方能獲得該鎖,重新進入可執行狀態。
這種機制確保瞭同一時刻對於每一個類實例,其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態(因為至多隻有一個能夠
獲得該類實例對應的鎖),從而有效避免瞭類成員變量的訪問沖突(隻要所有可能訪問類成員變量的方法均被聲明為 synchronized)。
在 Java 中,不光是類實例,每一個類也對應一把鎖,這樣我們也可將類的靜態成員函數聲明為 synchronized ,以控制其對類的靜態成員變量的
訪問。
synchronized 方法的缺陷:若將一個大的方法聲明為synchronized 將會大大影響效率,典型地,若將線程類的方法 run() 聲明為
synchronized ,由於在線程的整個生命期內它一直在運行,因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以
通過將訪問類成員變量的代碼放到專門的方法中,將其聲明為 synchronized ,並在主方法中調用來解決這一問題,但是 Java 為我們提供瞭更好
的解決辦法,那就是 synchronized 塊。

2. synchronized 塊

通過 synchronized關鍵字來聲明synchronized 塊。語法如下:
synchronized(syncObject) {
//允許訪問控制的代碼
}
synchronized 塊是這樣一個代碼塊,其中的代碼必須獲得對象 syncObject (如前所述,可以是類實例或類)的鎖方能執行,具體機制同前所述。
由於可以針對任意代碼塊,且可任意指定上鎖的對象,故靈活性較高。

一、當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時,一個時間內隻能有一個線程得到執行。
    另一個線程必須等待當前線程執行完這個代碼塊以後才能執行該代碼塊。

二、然而,當一個線程訪問object的一個synchronized(this)同步代碼塊時,另一個線程仍然可以訪問該object中的非
    synchronized(this)同步代碼塊。

三、尤其關鍵的是,當一個線程訪問object的一個synchronized(this)同步代碼塊時,其他線程對object中所有其它
    synchronized(this)同步代碼塊的訪問將被阻塞。

四、第三個例子同樣適用其它同步代碼塊。也就是說,當一個線程訪問object的一個synchronized(this)同步代碼塊時,
    它就獲得瞭這個object的對象鎖。結果,其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。

五、以上規則對其它對象鎖同樣適用.

舉例說明:

一、當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時,一個時間內隻能有一個線程得到執行。
    另一個線程必須等待當前線程執行完這個代碼塊以後才能執行該代碼塊。
package ths;

public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}

結果:

A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

二、然而,當一個線程訪問object的一個synchronized(this)同步代碼塊時,另一個線程仍然可以訪問該object中的非
    synchronized(this)同步代碼塊。

package ths;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i– > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i– > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt2.m4t1();
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt2.m4t2();
}
}, "t2"
);
t1.start();
t2.start();
}
}

結果:

t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0

三、尤其關鍵的是,當一個線程訪問object的一個synchronized(this)同步代碼塊時,其他線程對object中所有其它
    synchronized(this)同步代碼塊的訪問將被阻塞。

//修改Thread2.m4t2()方法:

public void m4t2() {
synchronized(this) {
int i = 5;
while( i– > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

}

結果:

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

四、第三個例子同樣適用其它同步代碼塊。也就是說,當一個線程訪問object的一個synchronized(this)同步代碼塊時,
    它就獲得瞭這個object的對象鎖。結果,其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。

//修改Thread2.m4t2()方法如下:

public synchronized void m4t2() {
int i = 5;
while( i– > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

結果:

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

五、以上規則對其它對象鎖同樣適用:
package ths;

public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i– > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i– > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用對象鎖
inner.m4t1();
}
}
private void m4t2(Inner inner) {
inner.m4t2();
}
public static void main(String[] args) {
final Thread3 myt3 = new Thread3();
final Inner inner = myt3.new Inner();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt3.m4t1(inner);
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt3.m4t2(inner);
}
}, "t2"
);
t1.start();
t2.start();
}
}

結果:

盡管線程t1獲得瞭對Inner的對象鎖,但由於線程t2訪問的是同一個Inner中的非同步部分。所以兩個線程互不幹擾。

t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0

現在在Inner.m4t2()前面加上synchronized:

private synchronized void m4t2() {
int i = 5;
while(i– > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}

結果:

盡管線程t1與t2訪問瞭同一個Inner對象中兩個毫不相關的部分,但因為t1先獲得瞭對Inner的對象鎖,所以t2對Inner.m4t2()的訪問也被阻塞,因為m4t2()是Inner中的一個同步方法。

t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0 

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。