詳細介紹Java同步塊synchronized block的使用

Java 同步區塊（synchronized block）用來標記方法或程式碼區塊是同步的。 Java同步塊用來避免競爭。本文介紹以下內容：

• Java同步關鍵字（synchronzied）

• 實例方法同步

• 靜態方法同步

實例方法中同步區塊

# 靜態方法中同步區塊

Java同步範例

1. Java 同步關鍵字（synchronized）

Java中的同步區塊以synchronized標記。同步區塊在Java中同步在某個
2. 物件

   上。所有同步在一個物件上的同步區塊在同時只能被一個執行緒進入並執行操作。所有其他等待進入該同步區塊的執行緒將被阻塞，直到執行該同步區塊中的執行緒

   退出
。

3. 有四個不同的同步區塊：

4. 實例方法

靜態方法

##實例方法中的同步區塊

靜態方法中的同步區塊

上述同步區塊都同步在不同物件上。實際上需要那種同步塊視具體情況而定。

實例方法同步

下面是一個同步的實例方法：

public synchronized void add(int value){
this.count += value;
 }

#注意在方法宣告中同步（synchronized ）關鍵字。這告訴Java該方法是同步的。

Java實例方法同步是同步在擁有該方法的物件上。這樣，每個實例其方法同步都同步在不同的物件上，也就是該方法所屬的實例。只有一個執行緒能夠在實例方法同步區塊中運行。如果有多個實例存在，那麼一個執行緒一次可以在一個實例同步區塊中執行操作。一個實例一個執行緒。

靜態方法同步

靜態方法同步和實例方法同步方法一樣，也使用synchronized 關鍵字。 Java靜態方法同步如下範例：

public static synchronized void add(int value){
 count += value;
 }

同樣，這裡synchronized 關鍵字告訴Java這個方法是同步的。

靜態方法的同步是指同步在該方法所在的類別物件上。因為在Java虛擬機器中一個類別只能對應一個類別對象，所以同時只允許一個執行緒執行同一個類別中的靜態同步方法。

對於不同類別中的靜態同步方法，一個執行緒可以執行每個類別中的靜態同步方法而無需等待。不管類別中的那個靜態同步方法被調用，一個類別只能由一個執行緒同時執行。

實例方法中的同步區塊

###有時你不需要同步整個方法，而是同步方法中的一部分。 Java可以對方法的一部分進行同步。 ######在非同步的Java方法中的同步區塊的範例如下所示：###

public void add(int value){

    synchronized(this){
       this.count += value;
    }
  }

###範例使用Java同步區塊建構器來標記一塊程式碼是同步的。該程式碼在執行時和同步方法一樣。 ######注意Java同步區塊建構器用括號將物件括起來。在上例中，使用了“this”，也就是呼叫add方法的實例本身。在同步建構器中用括號括起來的物件叫做監視器物件。上述程式碼使用監視器物件同步，同步實例方法使用呼叫方法本身的實例作為監視器物件。 ######一次只有一個執行緒能夠在同步於同一個監視器物件的Java方法內執行。 ######下面兩個例子都同步他們所呼叫的實例物件上，因此他們在同步的執行效果上是等效的。 ###

public class MyClass {

   public synchronized void log1(String msg1, String msg2){
      log.writeln(msg1);
      log.writeln(msg2);
   }

   public void log2(String msg1, String msg2){
      synchronized(this){
         log.writeln(msg1);
         log.writeln(msg2);
      }
   }
 }

###在上例中，每次只有一個執行緒能夠在兩個同步區塊中任意一個方法內執行。 ######如果第二個同步區塊不是同步在this實例物件上，那麼兩個方法可以被執行緒同時執行。 ######靜態方法中的同步區塊######和上方類似，下面是兩個靜態方法同步的範例。這些方法同步在該方法所屬的類別物件上。 ###

public class MyClass {
    public static synchronized void log1(String msg1, String msg2){
       log.writeln(msg1);
       log.writeln(msg2);
    }

    public static void log2(String msg1, String msg2){
       synchronized(MyClass.class){
          log.writeln(msg1);
          log.writeln(msg2);
       }
    }
  }

###這兩個方法不允許同時被執行緒存取。 ######如果第二個同步區塊不是同步在MyClass.class這個物件上。那麼這兩個方法可以同時被執行緒存取。 ######Java同步實例######在下面範例中，啟動了兩個線程，都呼叫Counter類別同一個實例的add方法。因為同步在該方法所屬的實例上，所以同時只能有一個執行緒存取該方法。 ###

public class Counter{
     long count = 0;

     public synchronized void add(long value){
       this.count += value;
     }
  }
  public class CounterThread extends Thread{

     protected Counter counter = null;

     public CounterThread(Counter counter){
        this.counter = counter;
     }

     public void run() {
    for(int i=0; i<10; i++){
           counter.add(i);
        }
     }
  }
  public class Example {

    public static void main(String[] args){
      Counter counter = new Counter();
      Thread  threadA = new CounterThread(counter);
      Thread  threadB = new CounterThread(counter);

      threadA.start();
      threadB.start();
    }
  }

创建了两个线程。他们的构造器引用同一个Counter实例。Counter.add方法是同步在实例上，是因为add方法是实例方法并且被标记上synchronized关键字。因此每次只允许一个线程调用该方法。另外一个线程必须要等到第一个线程退出add()方法时，才能继续执行方法。

如果两个线程引用了两个不同的Counter实例，那么他们可以同时调用add()方法。这些方法调用了不同的对象，因此这些方法也就同步在不同的对象上。这些方法调用将不会被阻塞。如下面这个例子所示：

public class Example {

   public static void main(String[] args){
     Counter counterA = new Counter();
     Counter counterB = new Counter();
     Thread  threadA = new CounterThread(counterA);
     Thread  threadB = new CounterThread(counterB);

     threadA.start();
     threadB.start();
   }
 }

注意这两个线程，threadA和threadB，不再引用同一个counter实例。CounterA和counterB的add方法同步在他们所属的对象上。调用counterA的add方法将不会阻塞调用counterB的add方法。

以上是詳細介紹Java同步塊synchronized block的使用的詳細內容。更多資訊請關注PHP中文網其他相關文章！