内容翻译稍感欠缺，待补充。有问题，请指正，多谢。
原文：Guide to the Synchronized Keyword in Java
1.概述
这是一篇关于Java中使用synchronized block的快速上手指南。
简单的说，在多线程环境中，当两个及以上的线程试图同时更新不变的共享数据时，会出现竞争的情况。Java提供了一个避免竞争的解决办法，通过同步访问共享数据的线程。
被synchronized关键字标注的一段代码会编程同步代码块，在给定的时间内只允许执行一个线程。
2.为什么使用Synchronization?
想想常见的一种竞争情况，在进行和运算时，多个线程同时执行calculate()方法。
public class BaeldungSynchronizedMethods {
private int sum = 0;
public void calculate() {
setSum(getSum() + 1);
}
// standard setters and getters
}
写一个简单的测试程序：
@Test
public void givenMultiThread_whenNonSyncMethod() {
ExecutorService service = Executors.newFixedThreadPool(3);
BaeldungSynchronizedMethods summation = new BaeldungSynchronizedMethods();
IntStream.range(0, 1000)
.forEach(count -> service.submit(summation::calculate));
service.awaitTermination(1000, TimeUnit.MILLISECONDS);
assertEquals(1000, summation.getSum());
}
上述代码使用ExecutorService线程池运行3个线程执行calculate()1000次。
如果按照顺序执行，会得到期望的结果1000。但是多个线程执行几乎每次 都会出现失败的情况，与实际的输出结果不一致，例如：
java.lang.AssertionError: expected:<1000> but was:<965>
at org.junit.Assert.fail(Assert.java:88)
at org.junit.Assert.failNotEquals(Assert.java:834)
这当然不是期望的结果。
一个简单方法就是使用synchronized关键字来避免出现竞争条件来保证操作线程安全。
3. Synchronized 关键字
synchronized关键字可用于不同的级别：
- 实例方法
- 静态方法
- 代码块
当使用synchronized块时，Java内部使用一个监视器（也称为监视锁或内部锁）来提供同步。这些监视器都是绑定到同一个对象上，因此同一个对象的所有同步代码块同时只能有一个线程来执行他们。
3.1 Synchronized 实例方法
简单地在方法声明前面添加synchronized关键字即可同步方法
public synchronized void synchronisedCalculate() {
setSum(getSum() + 1);
}
一旦我们同步synchronisedCalculate()，在上面的测试代码中会得到真正的输出结果1000.
@Test
public void givenMultiThread_whenMethodSync() {
ExecutorService service = Executors.newFixedThreadPool(3);
SynchronizedMethods method = new SynchronizedMethods();
IntStream.range(0, 1000)
.forEach(count -> service.submit(method::synchronisedCalculate));
service.awaitTermination(1000, TimeUnit.MILLISECONDS);
assertEquals(1000, method.getSum());
}
这些实例方法是在拥有这个方法的类实例中同步的。意味着该类的每个实例只有一个线程可以执行这个方法。
3.2 Synchronized 静态方法
静态方法使用与实例方法类似：
public static synchronized void syncStaticCalculate() {
staticSum = staticSum + 1;
}
这些方法在与类关联的类对象上进行同步，并且因为在每个JVM（Java虚拟机），每个类只存在一个类对象，因此在每个类的静态方法内部智能执行一个线程，而与该类有多少个实例无关。
注：静态方法、静态字段属于类，而非属于某个类的对象，调用的时候也是通过类来调用。
通过代码来测试一下：
@Test
public void givenMultiThread_whenStaticSyncMethod() {
ExecutorService service = Executors.newCachedThreadPool();
IntStream.range(0, 1000)
.forEach(count ->
service.submit(BaeldungSynchronizedMethods::syncStaticCalculate));
service.awaitTermination(100, TimeUnit.MILLISECONDS);
assertEquals(1000, BaeldungSynchronizedMethods.staticSum);
}
注意与实例方法的区别，一个通过实例调用方法，一个通过类调用方法。
3.3. Synchronized 方法内部 Blocks
有时，我们并不需要同步整个方法，只想同步方法内部的几条指令。这个可以通过同步代码块来实现，如下：
public void performSynchrinisedTask() {
synchronized (this) {
setCount(getCount()+1);
}
}
测试上述代码:
@Test
public void givenMultiThread_whenBlockSync() {
ExecutorService service = Executors.newFixedThreadPool(3);
BaeldungSynchronizedBlocks synchronizedBlocks =
new BaeldungSynchronizedBlocks();
IntStream.range(0, 1000)
.forEach(count ->
service.submit(synchronizedBlocks::performSynchronisedTask));
service.awaitTermination(100, TimeUnit.MILLISECONDS);
assertEquals(1000, synchronizedBlocks.getCount());
}
注意，在同步代码块中使用了this参数。this指的是监视器对象，代码块是在当前监视器对象得到同步的。简单的说，每个监视器对象只有一个线程可以执行该同步块中的代码。
如果方法是静态的，我们需要传递类名而非对象引用。该类会成为同步代码块的监视器：
public static void performStaticSyncTask(){
synchronized (SynchronisedBlocks.class) {
setStaticCount(getStaticCount() + 1);
}
}
测试静态方法中的代码块:
@Test
public void givenMultiThread_whenStaticSyncBlock() {
ExecutorService service = Executors.newCachedThreadPool();
IntStream.range(0, 1000)
.forEach(count ->
service.submit(BaeldungSynchronizedBlocks::performStaticSyncTask));
service.awaitTermination(100, TimeUnit.MILLISECONDS);
assertEquals(1000, BaeldungSynchronizedBlocks.getStaticCount());
}
4. 结论
在该快速指南中，我们了解了synchronized关键字几种的不同使用方法来实现线程同步。
我们了解了竞争情况是如何影响我们应用的，并且通过使用同步化来避免这种情况。如果要了解更多线程安全的知识，请参考 java.util.concurrent.Locks 文章。
完整代码示例请移步GitHub.
