同步方法和同步代碼塊

打個比方：一個object就像一個大房子，大門永遠打開。房子裏有不少房間（也就是方法）。這些房間有上鎖的（synchronized方法），和不上鎖之分（普通方法）。房門口放着一把鑰匙（key），這把鑰匙能夠打開全部上鎖的房間。另外我把全部想調用該對象方法的線程比喻成想進入這房子某個房間的人。全部的東西就這麼多了，下面咱們看看這些東西之間如何做用的。

在此咱們先來明確一下咱們的前提條件。該對象至少有一個synchronized方法，不然這個key還有啥意義。固然也就不會有咱們的這個主題了。

一我的想進入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明暫時尚未其餘人要使用上鎖的房間）。因而他走上去拿到了鑰匙，而且按照本身的計劃使用那些房間。注意一點，他每次使用完一次上鎖的房間後會立刻把鑰匙還回去。即便他要連續使用兩間上鎖的房間，中間他也要把鑰匙還回去，再取回來。

所以，普通狀況下鑰匙的使用原則是：「隨用隨借，用完即還。」

這時其餘人能夠不受限制的使用那些不上鎖的房間，一我的用一間能夠，兩我的用一間也能夠，沒限制。可是若是當某我的想要進入上鎖的房間，他就要跑到大門口去看看了。有鑰匙固然拿了就走，沒有的話，就只能等了。

要是不少人在等這把鑰匙，等鑰匙還回來之後，誰會優先獲得鑰匙？Not guaranteed。象前面例子裏那個想連續使用兩個上鎖房間的傢伙，他中間還鑰匙的時候若是還有其餘人在等鑰匙，那麼沒有任何保證這傢伙能再次拿到。（JAVA規範在不少地方都明確說明不保證，象Thread.sleep()休息後多久會返回運行，相同優先權的線程那個首先被執行，當要訪問對象的鎖被釋放後處於等待池的多個線程哪一個會優先獲得，等等。我想最終的決定權是在JVM，之因此不保證，就是由於JVM在作出上述決定的時候，毫不是簡簡單單根據一個條件來作出判斷，而是根據不少條。而因爲判斷條件太多，若是說出來可能會影響JAVA的推廣，也多是由於知識產權保護的緣由吧。SUN給了個不保證就混過去了。無可厚非。但我相信這些不肯定，並不是徹底不肯定。由於計算機這東西自己就是按指令運行的。即便看起來很隨機的現象，其實都是有規律可尋。學過計算機的都知道，計算機裏隨機數的學名是僞隨機數，是人運用必定的方法寫出來的，看上去隨機罷了。另外，或許是由於要想弄的肯定太費事，也沒多大意義，因此不肯定就不肯定了吧。）

再來看看同步代碼塊。和同步方法有小小的不一樣。

1.從尺寸上講，同步代碼塊比同步方法小。你能夠把同步代碼塊當作是沒上鎖房間裏的一塊用帶鎖的屏風隔開的空間。

2.同步代碼塊還能夠人爲的指定得到某個其它對象的key。就像是指定用哪一把鑰匙才能開這個屏風的鎖，你能夠用本房的鑰匙；你也能夠指定用另外一個房子的鑰匙才能開，這樣的話，你要跑到另外一棟房子那兒把那個鑰匙拿來，並用那個房子的鑰匙來打開這個房子的帶鎖的屏風。

記住你得到的那另外一棟房子的鑰匙，並不影響其餘人進入那棟房子沒有鎖的房間。

爲何要使用同步代碼塊呢？我想應該是這樣的：首先對程序來說同步的部分很影響運行效率，而一個方法一般是先建立一些局部變量，再對這些變量作一些操做，如運算，顯示等等；而同步所覆蓋的代碼越多，對效率的影響就越嚴重。所以咱們一般儘可能縮小其影響範圍。如何作？同步代碼塊。咱們只把一個方法中該同步的地方同步，好比運算。

另外，同步代碼塊能夠指定鑰匙這一特色有個額外的好處，是能夠在必定時期內霸佔某個對象的key。還記得前面說過普通狀況下鑰匙的使用原則嗎。如今不是普通狀況了。你所取得的那把鑰匙不是永遠不還，而是在退出同步代碼塊時才還。

還用前面那個想連續用兩個上鎖房間的傢伙打比方。怎樣才能在用完一間之後，繼續使用另外一間呢。用同步代碼塊吧。先建立另一個線程，作一個同步代碼塊，把那個代碼塊的鎖指向這個房子的鑰匙。而後啓動那個線程。只要你能在進入那個代碼塊時抓到這房子的鑰匙，你就能夠一直保留到退出那個代碼塊。也就是說你甚至能夠對本房內全部上鎖的房間遍歷，甚至再sleep(10601000)，而房門口卻還有1000個線程在等這把鑰匙呢。很過癮吧。

在此對sleep()方法和鑰匙的關聯性講一下。一個線程在拿到key後，且沒有完成同步的內容時，若是被強制sleep()了，那key還一直在它那兒。直到它再次運行，作完全部同步內容，纔會歸還key。記住，那傢伙只是幹活幹累了，去休息一下，他並沒幹完他要乾的事。爲了不別人進入那個房間把裏面搞的一團糟，即便在睡覺的時候他也要把那惟一的鑰匙戴在身上。

最後，也許有人會問，爲何要一把鑰匙通開，而不是一個鑰匙一個門呢？我想這純粹是由於複雜性問題。一個鑰匙一個門固然更安全，可是會牽扯好多問題。鑰匙的產生，保管，得到，歸還等等。其複雜性有可能隨同步方法的增長呈幾何級數增長，嚴重影響效率。

這也算是一個權衡的問題吧。爲了增長一點點安全性，致使效率大大下降，是多麼不可取啊。

摘自：http://www.54bk.com/more.asp?name=czp&id=2097

1、當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。

2、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另外一個線程仍然能夠訪問該object中的非synchronized(this)同步代碼塊。

3、尤爲關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其餘線程對object中全部其它synchronized(this)同步代碼塊的訪問將被阻塞。

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

5、以上規則對其它對象鎖一樣適用.

舉例說明：

1、當兩個併發線程訪問同一個對象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

2、然而，當一個線程訪問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

3、尤爲關鍵的是，當一個線程訪問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

4、第三個例子一樣適用其它同步代碼塊。也就是說，當一個線程訪問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

5、以上規則對其它對象鎖一樣適用:

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