用什麽關鍵字修飾同步方法 ? 用synchronized關鍵字修飾同步方法

同步有幾種實現方法,都是什麽?分別是synchronized,wait與notify

wait():使一個線程處於等待狀態，並且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException異常。
notify():喚醒一個處於等待狀態的線程，註意的是在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且不是按優先級。
Allnotity():喚醒所有處入等待狀態的線程，註意並不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。

實現同步的方式

同步是多線程中的重要概念。同步的使用可以保證在多線程運行的環境中，程序不會產生設計之外的錯誤結果。同步的實現方式有兩種，同步方法和同步塊，這兩種方式都要用到synchronized關鍵字。

給一個方法增加synchronized修飾符之後就可以使它成為同步方法，這個方法可以是靜態方法和非靜態方法，但是不能是抽象類的抽象方法，也不能是接口中的接口方法。下面代碼是一個同步方法的示例：

public synchronized void aMethod() {

// do something

}

public static synchronized void anotherMethod() {

// do something

}

線程在執行同步方法時是具有排它性的。當任意一個線程進入到一個對象的任意一個同步方法時，這個對象的所有同步方法都被鎖定了，在此期間，其他任何線程都不能訪問這個對象的任意一個同步方法，直到這個線程執行完它所調用的同步方法並從中退出，從而導致它釋放了該對象的同步鎖之後。在一個對象被某個線程鎖定之後，其他線程是可以訪問這個對象的所有非同步方法的。

同步塊是通過鎖定一個指定的對象，來對同步塊中包含的代碼進行同步；而同步方法是對這個方法塊裏的代碼進行同步，而這種情況下鎖定的對象就是同步方法所屬的主體對象自身。如果這個方法是靜態同步方法呢？那麽線程鎖定的就不是這個類的對象了，也不是這個類自身，而是這個類對應的Java.lang.Class類型的對象。同步方法和同步塊之間的相互制約只限於同一個對象之間，所以靜態同步方法只受它所屬類的其它靜態同步方法的制約，而跟這個類的實例（對象）沒有關系。

如果一個對象既有同步方法，又有同步塊，那麽當其中任意一個同步方法或者同步塊被某個線程執行時，這個對象就被鎖定了，其他線程無法在此時訪問這個對象的同步方法，也不能執行同步塊。

synchronized 關鍵字用於保護共享數據。請大家註意“共享數據”，你一定要分清哪些數據是共享數據，請看下面的例子：

public class ThreadTest implements Runnable{

public synchronized void run(){

for(int i=0;i<10;i++) {

System.out.print(" " + i);

}

}

public static void main(String[] args) {

Runnable r1 = new ThreadTest(); //也可寫成ThreadTest r1 = new ThreadTest();

Runnable r2 = new ThreadTest();

Thread t1 = new Thread(r1);

Thread t2 = new Thread(r2);

t1.start();

t2.start();

}}

在這個程序中，run()雖然被加上了synchronized 關鍵字，但保護的不是共享數據。因為這個程序中的t1,t2 是兩個對象（r1,r2）的線程。而不同的對象的數據是不同的，r1,r2 有各自的run()方法，所以輸出結果無法預知。

synchronized的目的是使同一個對象的多個線程，在某個時刻只有其中的一個線程可以訪問這個對象的synchronized 數據。每個對象都有一個“鎖標誌”，當這個對象的一個線程訪問這個對象的某個synchronized 數據時，這個對象的所有被synchronized 修飾的數據將被上鎖（因為“鎖標誌”被當前線程拿走了），只有當前線程訪問完它要訪問的synchronized 數據時，當前線程才會釋放“鎖標誌”，這樣同一個對象的其它線程才有機會訪問synchronized 數據。

示例3：

public class ThreadTest implements Runnable{

public synchronized void run(){

for(int i=0;i<10;i++){

System.out.print(" " + i);

}

}

public static void main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}}

如果你運行1000 次這個程序，它的輸出結果也一定每次都是：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。因為這裏的synchronized 保護的是共享數據。t1,t2 是同一個對象（r）的兩個線程，當其中的一個線程（例如：t1）開始執行run()方法時，由於run()受synchronized保護，所以同一個對象的其他線程（t2）無法訪問synchronized 方法（run 方法）。只有當t1執行完後t2 才有機會執行。

示例4：

public class ThreadTest implements Runnable{

public void run(){

synchronized(this){

for(int i=0;i<10;i++){

System.out.print(" " + i);

}} }

public static void main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}}

這個程序與示例3 的運行結果一樣。在可能的情況下，應該把保護範圍縮到最小，可以用示例4 的形式，this 代表“這個對象”。沒有必要把整個run()保護起來，run()中的代碼只有一個for循環，所以只要保護for 循環就可以了。

示例5：

public class ThreadTest implements Runnable{

public void run(){

for(int k=0;k<5;k++){

System.out.println(Thread.currentThread().getName()+ " : for loop : " + k);

}

synchronized(this){

for(int k=0;k<5;k++) {

System.out.println(Thread.currentThread().getName()+ " : synchronized for loop : " + k);

}} }

public static void main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = new Thread(r,"t1_name");

Thread t2 = new Thread(r,"t2_name");

t1.start();

t2.start();

} }

運行結果：

t1_name : for loop : 0

t1_name : for loop : 1

t1_name : for loop : 2

t2_name : for loop : 0

t1_name : for loop : 3

t2_name : for loop : 1

t1_name : for loop : 4

t2_name : for loop : 2

t1_name : synchronized for loop : 0

t2_name : for loop : 3

t1_name : synchronized for loop : 1

t2_name : for loop : 4

t1_name : synchronized for loop : 2

t1_name : synchronized for loop : 3

t1_name : synchronized for loop : 4

t2_name : synchronized for loop : 0

t2_name : synchronized for loop : 1

t2_name : synchronized for loop : 2

t2_name : synchronized for loop : 3

t2_name : synchronized for loop : 4

第一個for 循環沒有受synchronized 保護。對於第一個for 循環，t1,t2 可以同時訪問。運行結果表明t1 執行到了k=2 時，t2 開始執行了。t1 首先執行完了第一個for 循環，此時t2還沒有執行完第一個for 循環（t2 剛執行到k=2）。t1 開始執行第二個for 循環，當t1 的第二個for 循環執行到k=1 時，t2 的第一個for 循環執行完了。t2 想開始執行第二個for 循環，但由於t1 首先執行了第二個for 循環，這個對象的鎖標誌自然在t1 手中（synchronized 方法的執行權也就落到了t1 手中），在t1 沒執行完第二個for 循環的時候，它是不會釋放鎖標誌的。所以t2 必須等到t1 執行完第二個for 循環後，它才可以執行第二個for 循環。

線程同步的幾種方法