Java語言的keyword。當它用來修飾一個方法或者一個代碼塊的時候，可以保證在同一時刻最多僅僅有一個線程運行該段代碼。
一、當兩個並發線程訪問同一個對象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
第二篇：
synchronized keyword，它包含兩種使用方法：synchronized 方法和 synchronized 塊。
1. synchronized 方法：通過在方法聲明中增加 synchronizedkeyword來聲明 synchronized 方法。
如：
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變量的訪問：每一個類實例相應一把鎖，每一個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能
運行，否則所屬線程堵塞，方法一旦運行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此后被堵塞的線程方能獲得該鎖，又一次進入可運行
狀態。這樣的機制確保了同一時刻對於每個類實例。其全部聲明為 synchronized 的成員函數中至多僅僅有一個處於可運行狀態（由於至多僅僅有
一個可以獲得該類實例相應的鎖）。從而有效避免了類成員變量的訪問沖突（僅僅要全部可能訪問類成員變量的方法均被聲明為 synchronized）
。
在 Java 中，不光是類實例，每個類也相應一把鎖。這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成
員變量的訪問。
synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為
synchronized ，因為在線程的整個生命期內它一直在執行，因此將導致它對本類不論什么 synchronized 方法的調用都永遠不會成功。當然我們可
以通過將訪問類成員變量的代碼放到專門的方法中。將其聲明為 synchronized ，並在主方法中調用來解決這一問題，可是 Java 為我們提供
了更好的解決的方法，那就是 synchronized 塊。
2. synchronized 塊：通過 synchronizedkeyword來聲明synchronized 塊。語法例如以下：
synchronized(syncObject) {
//同意訪問控制的代碼
}
synchronized 塊是這樣一個代碼塊。當中的代碼必須獲得對象 syncObject （如前所述，能夠是類實例或類）的鎖方能運行，詳細機
制同前所述。因為能夠針對隨意代碼塊。且可隨意指定上鎖的對象，故靈活性較高。
對synchronized(this)的一些理解
一、當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內僅僅能有一個線程得到運行。
還有一個線
程必須等待當前線程運行完這個代碼塊以后才干運行該代碼塊。
二、然而。當一個線程訪問object的一個synchronized(this)同步代碼塊時。還有一個線程仍然能夠訪問該object中的非synchronized
(this)同步代碼塊。
三、尤其關鍵的是。當一個線程訪問object的一個synchronized(this)同步代碼塊時。其他線程對object中全部其他synchronized(this)
同步代碼塊的訪問將被堵塞。
四、第三個樣例相同適用其他同步代碼塊。
也就是說。當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個
object的對象鎖。結果，其他線程對該object對象全部同步代碼部分的訪問都被臨時堵塞。
五、以上規則對其他對象鎖相同適用
http://hi.baidu.com/sunshibing/blog/item/5235b9b731d48ff430add14a.html
java中synchronized使用方法
打個例如：一個object就像一個大房子，大門永遠打開。
房子里有 非常多房間（也就是方法）。
這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。
房門口放着一把鑰匙（key）。這把鑰匙能夠打開全部上鎖的房間。
另外我把全部想調用該對象方法的線程比喻成想進入這房子某個 房間的人。全部的東西就這么多了，以下我們看看這些東西之間怎樣作用的。
在此我們先來明白一下我們的前提條件。該對象至少有一個synchronized方法，否則這個key還有啥意義。
當然也就不會有我們的這個主題了。
一個人想進入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明臨時還沒有其它人要使用上鎖的 房間）。於是他走上去拿到了鑰匙
。而且依照自己 的計划使用那些房間。注意一點，他每次使用完一次上鎖的房間后會立即把鑰匙還回去。即使他要連續使用兩間上鎖的房間，
中間他也要把鑰匙還回去，再取回來。
因此，一般情況下鑰匙的使用原則是：“隨用隨借，用完即還。
”
這時其它人能夠不受限制的使用那些不上鎖的房間。一個人用一間能夠。兩個人用一間也能夠。沒限制。
可是假設當某個人想要進入上鎖的房
間，他就要跑到大門口去看看了。有鑰匙當然拿了就走，沒有的話，就僅僅能等了。
要是非常多人在等這把鑰匙，等鑰匙還回來以后。誰會優先得到鑰匙？Not guaranteed。象前面樣例里那個想連續使用兩個上鎖房間的家伙。他
中間還鑰匙的時候假設還有其它人在等鑰匙。那么沒有不論什么保證這家伙能再次拿到。 （JAVA規范在非常多地方都明白說明不保證，象
Thread.sleep()歇息后多久會返回執行，同樣優先權的線程那個首先被執行，當要訪問對象的鎖被 釋放后處於等待池的多個線程哪個會優先得
到，等等。我想終於的決定權是在JVM，之所以不保證，就是由於JVM在做出上述決定的時候，絕不是簡簡單單依據 一個條件來做出推斷，而是
依據非常多條。而由於推斷條件太多。假設說出來可能會影響JAVA的推廣，也可能是由於知識產權保護的原因吧。SUN給了個不保證 就混過去了
。無可厚非。但我相信這些不確定。並不是全然不確定。由於計算機這東西本身就是按指令執行的。
即使看起來非常隨機的現象，事實上都是有規律
可尋。學過 計算機的都知道，計算機里隨機數的學名是偽隨機數，是人運用一定的方法寫出來的，看上去隨機罷了。另外。也許是由於要想弄
的確定太費事。也沒多大意義，所 以不確定就不確定了吧。
）
再來看看同步代碼塊。
和同步方法有小小的不同。
1.從尺寸上講，同步代碼塊比同步方法小。你能夠把同步代碼塊看成是沒上鎖房間里的一塊用帶鎖的屏風隔開的空間。
2.同步代碼塊還能夠人為的指定獲得某個其他對象的key。就像是指定用哪一把鑰匙才干開這個屏風的鎖。你能夠用本房的鑰匙。你也能夠指定
用還有一個房子的鑰匙才干開。這種話，你要跑到還有一棟房子那兒把那個鑰匙拿來，並用那個房子的鑰匙來打開這個房子的帶鎖的屏風。
記住你獲得的那還有一棟房子的鑰匙，並不影響其它人進入那棟房子沒有鎖的房間。
為什么要使用同步代碼塊呢？我想應該是這種：首先對程序來講同步的部分非常影響執行效率，而一個方法一般是先創建一些局部變
量，再對這些變量做一些 操作，如運算，顯示等等；而同步所覆蓋的代碼越多。對效率的影響就越嚴重。因此我們通常盡量縮小其影響范圍。
怎樣做？同步代碼塊。我們僅僅把一個方法中該同 步的地方同步。比方運算。
另外，同步代碼塊能夠指定鑰匙這一特點有個額外的優點，是能夠在一定時期內霸占某個對象的key。還記得前面說過一般情況下鑰
匙的使用原則嗎。
如今不是一般情況了。你所取得的那把鑰匙不是永遠不還，而是在退出同步代碼塊時才還。
還用前面那個想連續用兩個上鎖房間的家伙打例如。如何才干在用完一間以后。繼續使用還有一間呢。
用同步代碼塊吧。先創建另外
一個線程，做一個同步代碼 塊，把那個代碼塊的鎖指向這個房子的鑰匙。然后啟動那個線程。僅僅要你能在進入那個代碼塊時抓到這房子的鑰匙
。你就能夠一直保留到退出那個代碼塊。也就是說 你甚至能夠對本房內全部上鎖的房間遍歷。甚至再sleep(10*60*1000)，而房門口卻還有
1000個線程在等這把鑰匙呢。非常過癮吧。
在此對sleep()方法和鑰匙的關聯性講一下。一個線程在拿到key后，且沒有完畢同步的內容時，假設被強制sleep()了。那key還一
直在 它那兒。
直到它再次執行。做全然部同步內容，才會歸還key。記住。那家伙僅僅是干活干累了，去歇息一下，他並沒干完他要干的事。為
了避免別人進入那個房間 把里面搞的一團糟。即使在睡覺的時候他也要把那唯一的鑰匙戴在身上。
最后，或許有人會問。為什么要一把鑰匙通開，而不是一個鑰匙一個門呢？我想這純粹是由於復雜性問題。一個鑰匙一個門當然更
安全。可是會牽扯好多問題。
鑰匙 的產生。保管，獲得，歸還等等。其復雜性有可能隨同步方法的添加呈幾何級數添加，嚴重影響效率。這也
算是一個權衡的問題吧。為了添加一點點安全性。導致效 率大大減少，是多么不可取啊。
synchronized的一個簡單樣例
public class TextThread {
public static void main(String[] args) {
TxtThread tt = new TxtThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}
class TxtThread implements Runnable {
int num = 100;
String str = new String();
public void run() {
synchronized (str) {
while (num > 0) {
try {
Thread.sleep(1);
} catch (Exception e) {
e.getMessage();
}
System.out.println(Thread.currentThread().getName()
+ "this is " + num--);
}
}
}
}
上面的樣例中為了制造一個時間差,也就是出錯的機會,使用了Thread.sleep(10)
Java對多線程的支持與同步機制深受大家的喜愛，似乎看起來使用了synchronizedkeyword就能夠輕松地解決多線程共享數據同步問題。究竟如
何？――還得對synchronizedkeyword的作用進行深入了解才可定論。
總的說來，synchronizedkeyword能夠作為函數的修飾符，也可作為函數內的語句，也就是平時說的同步方法和同步語句塊。
假設再細的分類，
synchronized可作用於instance變量、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。
在進一步闡述之前。我們須要明白幾點：
A．不管synchronizedkeyword加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數當作鎖――並且同步方法非常可能還會被其
他線程的對象訪問。
B．每一個對象僅僅有一個鎖（lock）與之相關聯。
C．實現同步是要非常大的系統開銷作為代價的。甚至可能造成死鎖，所以盡量避免無謂的同步控制。
接着來討論synchronized用到不同地方對代碼產生的影響：
如果P1、P2是同一個類的不同對象，這個類中定義了下面幾種情況的同步塊或同步方法，P1、P2就都能夠調用它們。
1． 把synchronized當作函數修飾符時，演示樣例代碼例如以下：
Public synchronized void methodAAA()
{
//….
}
這也就是同步方法，那這時synchronized鎖定的是哪個對象呢？它鎖定的是調用這個同步方法對象。
也就是說，當一個對象P1在不同的線程中
運行這個同步方法時，它們之間會形成相互排斥，達到同步的效果。可是這個對象所屬的Class所產生的還有一對象P2卻能夠隨意調用這個被加了
synchronizedkeyword的方法。
上邊的演示樣例代碼等同於例如以下代碼：
public void methodAAA()
{
synchronized (this) // (1)
{
//…..
}
}
(1)處的this指的是什么呢？它指的就是調用這種方法的對象，如P1。可見同步方法實質是將synchronized作用於object reference。――那個
拿到了P1對象鎖的線程，才干夠調用P1的同步方法，而對P2而言，P1這個鎖與它毫不相干，程序也可能在這樣的情形下擺脫同步機制的控制，造
成數據混亂：（
2．同步塊。演示樣例代碼例如以下：
public void method3(SomeObject so)
{
synchronized(so)
{
//…..
}
}
這時，鎖就是so這個對象，誰拿到這個鎖誰就能夠執行它所控制的那段代碼。當有一個明白的對象作為鎖時。就能夠這樣敲代碼，但當沒有明
確的對象作為鎖，僅僅是想讓一段代碼同步時。能夠創建一個特殊的instance變量（它得是一個對象）來充當鎖：
class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance變量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}
注：零長度的byte數組對象創建起來將比不論什么對象都經濟――查看編譯后的字節碼：生成零長度的byte[]對象僅僅需3條操作碼。而Object lock
= new Object()則須要7行操作碼。
3．將synchronized作用於static 函數，演示樣例代碼例如以下：
Class Foo
{
public synchronized static void methodAAA() // 同步的static 函數
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(類名稱字面常量)
}
}
代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數產生的效果是一樣的，取得的鎖非常特別，是當前調用這
個方法的對象所屬的類（Class，而不再是由這個Class產生的某個詳細對象了）。
記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用於作同步鎖還不一樣，不能用P1.getClass()來達到鎖這個Class的
目的。
P1指的是由Foo類產生的對象。
能夠判斷：假設一個類中定義了一個synchronized的static函數A。也定義了一個synchronized 的instance函數B。那么這個類的同一對象Obj
在多線程中分別訪問A和B兩個方法時，不會構成同步。由於它們的鎖都不一樣。
A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。
小結例如以下：
搞清楚synchronized鎖定的是哪個對象。就能幫助我們設計更安全的多線程程序。
另一些技巧能夠讓我們對共享資源的同步訪問更加安全：
1． 定義private 的instance變量+它的 get方法。而不要定義public/protected的instance變量。假設將變量定義為public，對象在外界能夠
繞過同步方法的控制而直接取得它，並修改它。
這也是JavaBean的標准實現方式之中的一個。
2． 假設instance變量是一個對象，如數組或ArrayList什么的，那上述方法仍然不安全。由於當外界對象通過get方法拿到這個instance對象
的引用后，又將其指向還有一個對象。那么這個private變量也就變了。豈不是非常危急。 這個時候就須要將get方法也加上synchronized同步。並
且，僅僅返回這個private對象的clone()――這樣。調用端得到的就是對象副本的引用了