Java：synchronized关键字

原帖收藏于IT老兵博客。

前言

这里翻译一篇对Java的synchronized关键字的讲解文章，这个关键字用于解决Java世界里面竞争条件时的访问冲突问题。

正文

Java synchronized块将方法或代码块标记为已同步。 Java synchronized块可用于避免竞争条件。

Java同步关键字

Java中的同步块使用synchronized关键字标记。Java中的同步块在某个对象上同步。在同一对象上的全部同步块在同一时刻只能被一个线程执行。尝试进入同步块的全部其余线程将被阻塞，直到同步块内的线程退出块。

synchronized关键字可用于标记四种不一样类型的块：

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

这些块在不一样对象上同步，您须要哪一种类型的同步块取决于具体状况。

同步实例方法

这是一个同步的实例方法：

public synchronized void add（int value）{
      this.count + = value;
  }

请注意在方法声明中使用synchronized关键字，这告诉Java该方法是同步的。

Java中的同步实例方法在拥有该方法的实例（对象）上同步。所以，每一个实例的同步方法在不一样的对象上同步：拥有它的实例。在一个同步实例方法中，只有一个线程能够执行。若是存在多个实例，则一次只能有一个线程能够在每一个实例的同步实例方法内执行。每一个实例一个线程。

同步静态方法

静态方法被标记为synchronized，就像使用synchronized关键字的实例方法同样。这是一个Java synchronized静态方法示例：

public static synchronized void add（int value）{
      count + = value;
  }

此处，synchronized关键字告诉Java该方法已同步。

同步静态方法在同步静态方法所属的类的类对象上同步。因为每一个类在Java VM中只存在一个类对象，所以在同一个类中的静态同步方法中只能执行一个线程。

若是静态同步方法位于不一样的类中，则一个线程能够在每一个类的静态同步方法内执行。每一个类一个线程，不管它调用哪一个静态同步方法。

实例方法中的同步块

您不须要同步整个方法，有时只须要同步方法的一部分。方法中的Java同步块使这成为可能。

如下是非同步Java方法中的同步Java代码块：

public void add（int value）{
    synchronized（this）{
       this.count + = value;
    }
  }

此示例使用Java synchronized块构造将代码块标记为已同步。此代码如今将像执行同步方法同样执行。

请注意Java synchronized块构造如何在括号中获取对象。在示例中使用“this”，这是调用add方法的实例。由synchronized构造在括号中获取的对象称为监视器对象。听说代码在监视器对象上同步。同步实例方法使用它所属的对象做为监视对象。

只有一个线程能够在同一监视器对象上同步的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）;
       }
    }
  }

所以，在该示例中，只有单个线程能够在两个同步块中的任一个内执行。

若是第二个同步块在与此不一样的对象上同步，则一次一个线程就可以在每一个方法内执行。

静态方法中的同步块

如下是与静态方法相同的两个示例。这些方法在方法所属的类的类对象上同步：

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同步例子

下面是一个示例，它启动2个线程并让它们在同一个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实例在其构造函数中传递给它们。 Counter.add()方法在实例上同步，由于add方法是一个实例方法，并标记为synchronized。 所以，只有一个线程能够一次调用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(); 
    }
  }

注意两个线程threadA和threadB如何再也不引用相同的计数器实例。 counterA和counterB的add方法在它们的两个拥有实例上同步。 所以，在counterA上调用add()将不会阻止对counterB的add()调用。

Java并发实用程序

同步机制是Java的第一种机制，用于同步对多个线程共享的对象的访问。但同步机制并非很先进。 这就是为何Java 5得到了一整套concurrency utility classes来帮助开发人员实现比同步所得到的更细粒度的并发控制。

总结

这篇文章对synchronized关键字进行了详细的讲解，我的感受讲解的不错，翻译出来，作个记录。

参考

http://tutorials.jenkov.com/java-concurrency/synchronized.html