快捷導(dǎo)航

Java 中 synchronized的用法詳解(四種用法)

更新時間：2015年11月09日 11:47:56 投稿：mrr

Java語言的關(guān)鍵字，當(dāng)它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個線程執(zhí)行該段代碼。本文給大家介紹java中 synchronized的用法，對本文感興趣的朋友一起看看吧

Java語言的關(guān)鍵字，當(dāng)它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個線程執(zhí)行該段代碼。

1.方法聲明時使用,放在范圍操作符(public等)之后,返回類型聲明(void等)之前.這時,線程獲得的是成員鎖,即一次只能有一個線程進入該方法,其他線程要想在此時調(diào)用該方法,只能排隊等候,當(dāng)前線程(就是在synchronized方法內(nèi)部的線程)執(zhí)行完該方法后,別的線程才能進入.

例如:

   public synchronized void synMethod() {
    //方法體
   }

2.對某一代碼塊使用,synchronized后跟括號,括號里是變量,這樣,一次只有一個線程進入該代碼塊.此時,線程獲得的是成員鎖.例如:

   public int synMethod(int a1){
    synchronized(a1) {
     //一次只能有一個線程進入
    }
   }

3.synchronized后面括號里是一對象,此時,線程獲得的是對象鎖.例如:

 public class MyThread implements Runnable {
  public static void main(String args[]) {
  MyThread mt = new MyThread();
  Thread t1 = new Thread(mt, "t1");
  Thread t2 = new Thread(mt, "t2");
  Thread t3 = new Thread(mt, "t3");
  Thread t4 = new Thread(mt, "t4");
  Thread t5 = new Thread(mt, "t5");
  Thread t6 = new Thread(mt, "t6");
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  t5.start();
  t6.start();
 }
 public void run() {
  synchronized (this) {
   System.out.println(Thread.currentThread().getName());
  }
 }
}

對于3,如果線程進入,則得到當(dāng)前對象鎖,那么別的線程在該類所有對象上的任何操作都不能進行.在對象級使用鎖通常是一種比較粗糙的方法。為什么要將整個對象都上鎖，而不允許其他線程短暫地使用對象中其他同步方法來訪問共享資源？如果一個對象擁有多個資源，就不需要只為了讓一個線程使用其中一部分資源，就將所有線程都鎖在外面。由于每個對象都有鎖，可以如下所示使用虛擬對象來上鎖：

class FineGrainLock {
  MyMemberClass x, y;
  Object xlock = new Object(), ylock = new Object();
  public void foo() {
   synchronized(xlock) {
     //access x here
   }
   //do something here - but don't use shared resources
   synchronized(ylock) {
     //access y here
   }
  }
  public void bar() {
   synchronized(this) {
     //access both x and y here
   }
   //do something here - but don't use shared resources
  }
 }

4.synchronized后面括號里是類,此時,線程獲得的是對象鎖.例如:

class ArrayWithLockOrder{
 private static long num_locks = 0;
 private long lock_order;
 private int[] arr;
 public ArrayWithLockOrder(int[] a)
 {
  arr = a;
  synchronized(ArrayWithLockOrder.class) {//-----這里
   num_locks++;       // 鎖數(shù)加 1。
   lock_order = num_locks; // 為此對象實例設(shè)置唯一的 lock_order。
  }
 }
 public long lockOrder()
 {
  return lock_order;
 }
 public int[] array()
 {
  return arr;
 }
 }
 class SomeClass implements Runnable
 {
 public int sumArrays(ArrayWithLockOrder a1,
            ArrayWithLockOrder a2)
 {
  int value = 0;
  ArrayWithLockOrder first = a1;    // 保留數(shù)組引用的一個
  ArrayWithLockOrder last = a2;    // 本地副本。
  int size = a1.array().length;
  if (size == a2.array().length)
  {
   if (a1.lockOrder() > a2.lockOrder()) // 確定并設(shè)置對象的鎖定
   {                   // 順序。
    first = a2;
    last = a1;
   }
   synchronized(first) {       // 按正確的順序鎖定對象。
    synchronized(last) {
     int[] arr1 = a1.array();
     int[] arr2 = a2.array();
     for (int i=0; i<size; i++)
      value += arr1[i] + arr2[i];
    }
   }
  }
  return value;
 }
 public void run() {
  //
 }
 }

對于4,如果線程進入,則線程在該類中所有操作不能進行,包括靜態(tài)變量和靜態(tài)方法,實際上,對于含有靜態(tài)方法和靜態(tài)變量的代碼塊的同步,我們通常用4來加鎖.

PS：synchronized 用法總結(jié)

synchronized用到不同地方對代碼產(chǎn)生的影響：

1. synchronized關(guān)鍵字修飾方法

假設(shè)P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都能夠調(diào)用他們。

public synchronized void method(){
  // 
}

這也就是同步方法，那這時synchronized鎖定的是調(diào)用這個同步方法對象。也就是說，當(dāng)一個對象P1在不同的線程中執(zhí)行這個同步方法時，他們之間會形成互斥，達到同步的效果。同時如果該對象中有多個同步方法，則當(dāng)一個線程獲執(zhí)行對象中的一個synchronized方法，則該對象中其它同步方法也不允許別的線程執(zhí)行。但是這個對象所屬的Class所產(chǎn)生的另一對象P2卻能夠任意調(diào)用這個被加了synchronized關(guān)鍵字的方法。

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

public void method()  {  
  synchronized (this)   
  {  
    //..  
  }  
}

此次就是一個P1對象的對象鎖，哪個拿到了P1對象鎖的線程，才能夠調(diào)用P1的同步方法，而對P2而言，P1這個鎖和他毫不相干，程式也可能在這種情形下擺脫同步機制的控制，造成數(shù)據(jù)混亂。

2．同步塊，示例代碼如下：

public void method() { 
synchronized (this) 
{ 
//.. 
} 
}

這時，鎖就是so這個對象，每個對象對應(yīng)一個唯一的鎖，所以哪個線程拿到這個對象鎖誰就能夠運行他所控制的那段代碼。當(dāng)有一個明確的對象作為鎖時，就能夠這樣寫程式，但當(dāng)沒有明確的對象作為鎖，只是想讓一段代碼同步時，能夠創(chuàng)建一個特別的instance變量（他得是個對象）來充當(dāng)鎖：

 private byte[] lock = new byte[0]; 
  Public void method(){  
      synchronized(lock) 
      { 
        // 
      }
  }

注：零長度的byte數(shù)組對象創(chuàng)建起來將比任何對象都經(jīng)濟――查看編譯后的字節(jié)碼：生成零長度的byte[]對象只需3條操作碼，而Object lock = new Object()則需要7行操作碼。

3．將synchronized作用于static 函數(shù)，示例代碼如下：

Class Foo  
{  
  public synchronized static void method1()  

  {  
    //.  
  }  
  public void method2()  
  {  
    synchronized(Foo.class)  
    //
  }  
}

這兩個同步方法都調(diào)用這個方法的對象所屬的類的類鎖（Class，而不再是由這個Class產(chǎn)生的某個具體對象了）。
能夠推斷：假如一個類中定義了一個synchronized的static函數(shù)A，也定義了一個synchronized 的instance函數(shù)B，那么這個類的同一對象Obj在多線程中分別訪問A和B兩個方法時，不會構(gòu)成同步，因為他們的鎖都不相同。A方法的鎖是Obj所屬的那個Class，而B的鎖是Obj所屬的這個對象。

您可能感興趣的文章: