1.方法宣告時使用,放在範圍操作符(public等)之後,返回型別宣告(void等)之前.這時,執行緒獲得的是成員鎖,即一次只能有一個執行緒進入該方法,其他執行緒要想在此時呼叫該方法,只能排隊等候,當前執行緒(就是在synchronized方法內部的執行緒)執行完該方法後,別的執行緒才能進入.
 
      例如:

{
        //方法體
      }

    2.對某一程式碼塊使用,synchronized後跟括號,括號裡是變數,這樣,一次只有一個執行緒進入該程式碼塊.此時,執行緒獲得的是成員鎖.例如:

{
        synchronized(a1) {
          //一次只能有一個執行緒進入
        }
      }

    3.synchronized後面括號裡是一物件,此時,執行緒獲得的是物件鎖.例如:

{
    publicstaticvoid 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();
  }

  publicvoid run() {
    synchronized (this

) {
      System.out.println(Thread.currentThread().getName());
    }
  }
}

 
 

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

{

   MyMemberClass x, y;
   Object xlock =new Object(), ylock =new Object();

   publicvoid foo() {
      synchronized(xlock) {
         //access x here
      }

      //do something here - but don't use shared resources

      synchronized(ylock) {
         //access y here
      }
   }

   publicvoid bar() {
      synchronized(this) {
         //access both x and y here
      }
      //do something here - but don't use shared resources
   }
  }

     4.synchronized後面括號裡是類,此時,執行緒獲得的是物件鎖.例如:

{
  privatestaticlong num_locks =0;
  privatelong lock_order;
  privateint[] arr;

  public ArrayWithLockOrder(int[] a)
  {
    arr = a;
    synchronized(ArrayWithLockOrder.class) {//-----這裡
      num_locks++;             // 鎖數加 1。

      lock_order = num_locks;  // 為此物件例項設定唯一的 lock_order。
    }
  }
  publiclong lockOrder()
  {
    return lock_order;
  }
  publicint[] array()
  {
    return arr;
  }
  }

  

 SomeClass implements Runnable
 

{
  publicint sumArrays(ArrayWithLockOrder a1,
                       ArrayWithLockOrder a2)
  {
    int value =0;
    ArrayWithLockOrder first = a1;       // 保留陣列引用的一個
    ArrayWithLockOrder last = a2;        // 本地副本。
int size = a1.array().length;
    if (size == a2.array().length)
    {
      if (a1.lockOrder() > a2.lockOrder())  // 確定並設定物件的鎖定
{                                     // 順序。
        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;

  }
  publicvoid run() {
    //
  }
  }

  
    對於4,如果執行緒進入,則執行緒在該類中所有操作不能進行,包括靜態變數和靜態方法,實際上,對於含有靜態方法和靜態變數的程式碼塊的同步,我們通常用4來加鎖.