12.Java同步代码块

一个Java同步块使得一个方法或者代码块作为同步的。Java同步块可以用来避免静态条件。

这个Java同步关键字

在Java中的同步块通过使用synchronized关键字作为标记。在Java中的一个同步块是在一些对象上同步的。同步在所有对象上的所有同步块只能同时有一个线程执行。所有尝试进入到同步块的其他线程被堵塞，直到同步块内部的这个线程离开这个块。

这个synchronized关键字可以用来标记四种不同类型的块：

1. 实例方法
2. 静态方法
3. 实例方法中的代码块
4. 静态方法中的代码块

这些块在不同的对象中被同步。你需要哪种同步块类型依赖于具体的场景。 同步的实例方法 这里有一个例子：

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

注意在方法生命中synchronized关键字的使用。这个告诉Java这个方法被同步了。

在Java中的一个同步实例方法是在属于这个方法的实例对象上同步的。因此，每一个实例都有它的同步方法同步在不同的对象上：自己拥有的实例。只有一个线程可以执行一个实例同步方法，然后一个线程可以每次执行一个同步实例方法。每一个实例一个线程。

同步的静态方法

静态方法被标记为同步的就跟实例方法使用synchronized关键字一样。这里有一个实例：

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

这里也有一个synchronized关键字告诉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方法。一次只能有一个线程能够调用相同实例的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实例传递给了它们的构造函数。这个add方法在实例上被同步了，因为这个add方法是一个实例方法，并且标记为同步的。因此一次只能有一个线程调用这个add方法。其他的线程将会等待直到第一个线程离开这个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(); 
    }
  }
           

注意这两个线程，他们不再引用相同的实例。counterA和counterB的add方法同步在它们自己的实例上。因此不会堵塞。

Java并发工具

这个synchronized机制是java的第一个途径对于访问同步访问被多线程共享的对象。但是这个synchronized机制不是最高级的。那就是为什么Java 5提供了一个并发工具类的集合去帮助开发者实现更细粒度的并发控制相对于synchronized而言。

翻译地址：http://tutorials.jenkov.com/java-concurrency/synchronized.html