javasynchronized修飾符

A. java中修飾符有哪些

java的修飾符有：許可權修飾符：public、protected、default、private

修飾符：abstract、static、final

public 使用對象：最廣，類、介面、變數、方法

protected使用對象：變數、方法 注意：不能修飾類（外部類）

default 使用對象：類、介面、變數、方法。（即預設，什麼也不寫）

private 使用對象：變數、方法 注意：不能修飾類（外部類）

abstract使用對象：類、介面、方法

static 使用對象：類、變數、方法、初始化函數（注意：修飾類時只能修飾 內部類 ）

final 使用對象：類、變數、方法

transient：告訴編譯器，在類對象序列化的時候，此變數不需要持久保存

volatile：指出可能有多個線程修改此變數，要求編譯器優化以保證對此變數的修改能夠被正確的處理

native：用該修飾符定義的方法在類中沒有實現，而大多數情況下該方法的實現是用C、C++編寫的。

synchronized：修飾方法，多線程的支持

類分外部類和內部類，他們的訪問控制是相同的嗎

外部類是相對於內部類而言的，內部類是定義在類裡面的類。

外部類的修飾符有：

default（預設，不寫）：類定義時前面未加任何修飾符，表示同一個包中可見。

public：修飾類時表示該類能被項目中所有類可見

abstract：表示是抽象類

final：表示類不可以被繼承

scrictpf:(java關鍵字) 當對一個類或介面使用 strictfp 關鍵字時，該類中的所有代碼，包括嵌套類型中的初始設定值和代碼，都將嚴格地進行計算。嚴格約束意味著所有表達式的結果都必須是 IEEE 754 演算法對操作數預期的結果，以單精度和雙精度格式表示

內部類又分：成員內部類、局部內部類、靜態內部類、匿名內部類

成員內部類：作為外部類的一個成員存在，與外部類的屬性、方法並列

局部內部類：定義在外部類的方法體裡面的類

靜態內部類：使用static修飾的內部類

匿名內部類：就是沒有名字的內部類

成員內部類修飾符有：

public：

protected：

private：private不能修飾外部類，

abstract：

final：

static：可以當做普通類使用，而不用先實例化一個外部類。（用他修飾後，就成了靜態內部類了）

strictfp：（java關鍵字） 即 strict float point (精確浮點)。（可修飾類、介面、方法）

(1)javasynchronized修飾符擴展閱讀：

java中的類修飾符、成員變數修飾符、方法修飾符。

類修飾符：

public（訪問控制符），將一個類聲明為公共類，他可以被任何對象訪問，一個程序的主類必須是公共類。

abstract，將一個類聲明為抽象類，沒有實現的方法，需要子類提供方法實現。

final，將一個類生命為最終（即非繼承類），表示他不能被其他類繼承。

friendly，默認的修飾符，只有在相同包中的對象才能使用這樣的類。

成員變數修飾符：

public（公共訪問控制符），指定該變數為公共的，他可以被任何對象的方法訪問。

private（私有訪問控制符）指定該變數只允許自己的類的方法訪問，其他任何類（包括子類）中的方法均不能訪問。

protected（保護訪問控制符）指定該變數可以別被自己的類和子類訪問。在子類中可以覆蓋此變數。

friendly ，在同一個包中的類可以訪問，其他包中的類不能訪問。

final，最終修飾符，指定此變數的值不能變。

static（靜態修飾符）指定變數被所有對象共享，即所有實例都可以使用該變數。變數屬於這個類。

transient（過度修飾符）指定該變數是系統保留，暫無特別作用的臨時性變數。

volatile（易失修飾符）指定該變數可以同時被幾個線程式控制制和修改。

方法修飾符：

public（公共控制符）

private（私有控制符）指定此方法只能有自己類等方法訪問，其他的類不能訪問（包括子類）

protected（保護訪問控制符）指定該方法可以被它的類和子類進行訪問。

final，指定該方法不能被重載。

static，指定不需要實例化就可以激活的一個方法。

synchronize，同步修飾符，在多個線程中，該修飾符用於在運行前，對他所屬的方法加鎖，以防止其他線程的訪問，運行結束後解鎖。

native，本地修飾符。指定此方法的方法體是用其他語言在程序外部編寫的。

B. synchronized 加在java方法前面是什麼作用

Java語言的關鍵字，當它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多隻有一個線程執行該段代碼。

一、當兩個並發線程訪問同一個對象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 關鍵字，它包括兩種用法：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 （如前所述，可以是類實例或類）的鎖方能執行，具體機

制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。
對synchronized(this)的一些理解
一、當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程得到執行。另一個線

程必須等待當前線程執行完這個代碼塊以後才能執行該代碼塊。
二、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized

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

同步代碼塊的訪問將被阻塞。
四、第三個例子同樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個

object的對象鎖。結果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。
五、以上規則對其它對象鎖同樣適用

http://hi..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對多線程的支持與同步機制深受大家的喜愛，似乎看起來使用了synchronized關鍵字就可以輕松地解決多線程共享數據同步問題。到底如

何？――還得對synchronized關鍵字的作用進行深入了解才可定論。

總的說來，synchronized關鍵字可以作為函數的修飾符，也可作為函數內的語句，也就是平時說的同步方法和同步語句塊。如果再細的分類，

synchronized可作用於instance變數、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。

在進一步闡述之前，我們需要明確幾點：

A．無論synchronized關鍵字加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數當作鎖――而且同步方法很可能還會被其

他線程的對象訪問。

B．每個對象只有一個鎖（lock）與之相關聯。

C．實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。

接著來討論synchronized用到不同地方對代碼產生的影響：

假設P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調用它們。

1． 把synchronized當作函數修飾符時，示例代碼如下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時synchronized鎖定的是哪個對象呢？它鎖定的是調用這個同步方法對象。也就是說，當一個對象P1在不同的線程中

執行這個同步方法時，它們之間會形成互斥，達到同步的效果。但是這個對象所屬的Class所產生的另一對象P2卻可以任意調用這個被加了

synchronized關鍵字的方法。

上邊的示例代碼等同於如下代碼：

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()――這樣，調用端得到的就是對象副本的引用了

C. Synchronized 同步方法的八種使用場景

分析：這種情況是經典的對象鎖中的方法鎖，兩個線程爭奪同一個對象鎖，所以會相互等待，是線程安全的。

兩個線程同時訪問同一個對象的同步方法，是線程安全的。

這種場景就是對象鎖失效的場景，原因出在訪問的是兩個對象的同步方法，那麼這兩個線程分別持有的兩個線程的鎖，所以是互相不會受限的。加鎖的目的是為了讓多個線程競爭同一把鎖，而這種情況多個線程之間不再競爭同一把鎖，而是分別持有一把鎖，所以我們的結論是：

兩個線程同時訪問兩個對象的同步方法，是線程不安全的。

運行結果：
兩個線程是並行執行的，所以線程不安全。

線程名：Thread-0，運行開始
線程名：Thread-1，運行開始
線程：Thread-0，運行結束
線程：Thread-1，運行結束
測試結束

兩個線程（thread1、thread2），訪問兩個對象（instance1、instance2）的同步方法（method()）,兩個線程都有各自的鎖，不能形成兩個線程競爭一把鎖的局勢，所以這時，synchronized修飾的方法method()和不用synchronized修飾的效果一樣（不信去把synchronized關鍵字去掉，運行結果一樣），所以此時的method()只是個普通方法。

若要使鎖生效，只需將method()方法用static修飾，這樣就形成了類鎖，多個實例（instance1、instance2）共同競爭一把類鎖，就可以使兩個線程串列執行了。這也就是下一個場景要講的內容。

這個場景解決的是場景二中出現的線程不安全問題，即用類鎖實現：

兩個線程同時訪問（一個或兩個）對象的靜態同步方法，是線程安全的。

這個場景是兩個線程其中一個訪問同步方法，另一個訪問非同步方法，此時程序會不會串列執行呢，也就是說是不是線程安全的呢？
我們可以確定是線程不安全的，如果方法不加synchronized都是安全的，那就不需要同步方法了。驗證下我們的結論：

兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法，是線程不安全的。

兩個線程是並行執行的，所以是線程不安去的。

線程名：Thread-0，同步方法，運行開始
線程名：Thread-1，普通方法，運行開始
線程：Thread-0，同步方法，運行結束
線程：Thread-1，普通方法，運行結束
測試結束

問題在於此：method1沒有被synchronized修飾，所以不會受到鎖的影響。即便是在同一個對象中，當然在多個實例中，更不會被鎖影響了。結論：

非同步方法不受其它由synchronized修飾的同步方法影響

你可能想到一個類似場景：多個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法，這個場景會是線程安全的嗎？

我們來實驗下這個場景，用兩個線程調用同步方法，在同步方法中調用普通方法；再用一個線程直接調用普通方法，看看是否是線程安全的？

線程名：Thread-0，普通方法，運行開始
線程名：Thread-1，同步方法，運行開始
線程：Thread-1，同步方法，運行結束,開始調用普通方法
線程名：Thread-1，普通方法，運行開始
線程：Thread-0，普通方法，運行結束
線程：Thread-1，普通方法，運行結束
線程名：Thread-2，同步方法，運行開始
線程：Thread-2，同步方法，運行結束,開始調用普通方法
線程名：Thread-2，普通方法，運行開始
線程：Thread-2，普通方法，運行結束
測試結束

我們可以看出，普通方法被兩個線程並行執行，不是線程安全的。這是為什麼呢？

因為如果非同步方法，有任何其他線程直接調用，而不是僅在調用同步方法時，才調用非同步方法，此時會出現多個線程並行執行非同步方法的情況，線程就不安全了。

對於同步方法中調用非同步方法時，要想保證線程安全，就必須保證非同步方法的入口，僅出現在同步方法中。但這種控制方式不夠優雅，若被不明情況的人直接調用非同步方法，就會導致原有的線程同步不再安全。所以不推薦大家在項目中這樣使用，但我們要理解這種情況，並且我們要用語義明確的、讓人一看就知道這是同步方法的方式，來處理線程安全的問題。

所以，最簡單的方式，是在非同步方法上，也加上synchronized關鍵字，使其變成一個同步方法，這樣就變成了《場景五：兩個線程同時訪問同一個對象的不同的同步方法》，這種場景下，大家就很清楚的看到，同一個對象中的兩個同步方法，不管哪個線程調用，都是線程安全的了。

兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法，僅在沒有其他線程直接調用非同步方法的情況下，是線程安全的。若有其他線程直接調用非同步方法，則是線程不安全的。

這個場景也是在探討對象鎖的作用范圍，對象鎖的作用范圍是對象中的所有同步方法。所以，當訪問同一個對象中的多個同步方法時，結論是：

兩個線程同時訪問同一個對象的不同的同步方法時，是線程安全的。

是線程安全的。

線程名：Thread-1，同步方法1，運行開始
線程：Thread-1，同步方法1，運行結束
線程名：Thread-0，同步方法0，運行開始
線程：Thread-0，同步方法0，運行結束
測試結束

兩個方法（method0()和method1()）的synchronized修飾符，雖沒有指定鎖對象，但默認鎖對象為this對象為鎖對象，
所以對於同一個實例（instance），兩個線程拿到的鎖是同一把鎖，此時同步方法會串列執行。這也是synchronized關鍵字的可重入性的一種體現。

線程名：Thread-0，靜態同步方法0，運行開始
線程名：Thread-1，非靜態同步方法1，運行開始
線程：Thread-1，非靜態同步方法1，運行結束
線程：Thread-0，靜態同步方法0，運行結束
測試結束

本場景探討的是synchronized釋放鎖的場景：

只有當同步方法執行完或執行時拋出異常這兩種情況，才會釋放鎖。

所以，在一個線程的同步方法中出現異常的時候，會釋放鎖，另一個線程得到鎖，繼續執行。而不會出現一個線程拋出異常後，另一個線程一直等待獲取鎖的情況。這是因為JVM在同步方法拋出異常的時候，會自動釋放鎖對象。

線程名：Thread-0，運行開始
線程名：Thread-0，拋出異常，釋放鎖
線程名：Thread-1，運行開始
Exception in thread "Thread-0" java.lang.RuntimeException
at com.study.synchronize.conditions.Condition7.method0(Condition7.java:34)
at com.study.synchronize.conditions.Condition7.run(Condition7.java:17)
at java.lang.Thread.run(Thread.java:748)
線程：Thread-1，運行結束
測試結束

可以看出線程還是串列執行的，說明是線程安全的。而且出現異常後，不會造成死鎖現象，JVM會自動釋放出現異常線程的鎖對象，其他線程獲取鎖繼續執行。