1. 概览
这篇文章将会介绍java中的同步代码块。
在多线程环境中，当俩个或多个线程试图在同一时间更新一个互斥共享数据时，就会产生竞争(race condition)。java提供了一整套机制去避免竞争，那就是当线程对共享数据访问时进行同步synchronize操作。
2. 为什么要同步？
我们来设想一个最典型的竞争场景，那就是在我们进行求和运算时，有多个线程执行calcute()方法：
public class BaeldungSynchronizedMethods
privateintsum = 0;
public void calculate() {
setSum(getSum() + 1);
}
// standard setters and getters
}
现在我们来写一个简单得测试：
@Test
public void givenMultiThread_whenNonSyncMethod() {
ExecutorService service = Executors.newFixedThreadPool(3);
BaeldungSynchronizedMethods summation = newBaeldungSynchronizedMethods();
IntStream.range(0, 1000)
.forEach(count -> service.submit(summation::calculate));
service.awaitTermination(1000, TimeUnit.MILLISECONDS);
assertEquals(1000, summation.getSum());
}
很简单，我们使用一个拥有3个线程池的ExecutorService 去运行1000次 calculte()方法。如果我们串行地运行，期望的结果是1000，但是，几乎每一次当我们使用多线程去执行时，都是失败的，得到的是不一致的输出结果
e.g:
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内部会使用一个监视器monitor(也就是大家熟知的，monitor lock 或 intrinsic lock) 去提供同步。这些monitor都会和一个对象绑定，因此，相同对象的所有同步代码块在同一时刻只会有一个线程在执行。
3.1 同步实例方法
简单地把synchronized关键字放在方法声明里就能让方法同步：
publicsynchronizedvoidsynchronisedCalculate() {
setSum(getSum() + 1);
}
请注意，一旦我们同步了这个方法，这个测试案例就执行通过了，并且输出了1000：
@Test
publicvoidgivenMultiThread_whenMethodSync() {
ExecutorService service = Executors.newFixedThreadPool(3);
SynchronizedMethods method = newSynchronizedMethods();
IntStream.range(0, 1000)
.forEach(count -> service.submit(method::synchronisedCalculate));
service.awaitTermination(1000, TimeUnit.MILLISECONDS);
assertEquals(1000, method.getSum());
}
实例方法将借助于该类的实例实现同步，也就是意味着 该类的每一个实例只有一个线程能执行同步方法。
3.2 同步静态方法
对静态方法做同步就和实例方法一样：
public static synchronized void syncStaticCalculate() {
staticSum = staticSum + 1;
}
使用该类所关联的Class对象来对这些静态方法同步。同时，由于一个JVM中的每一个类只存在一个Class对象，因此，不管该类有多少实例数量， 每个类都只有一个线程能执行该静态方法。
我们来测试一下：
@Test
publicvoidgivenMultiThread_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 方法内部的同步代码块
有时，我们并不想同步整个方法，而仅仅想同步的是该方法中的某一些代码。通过使用同步代码块可以实现这个目的。
publicvoid performSynchrinisedTask() {
synchronized (this) {
setCount(getCount()+1);
}
}
我们来测试一下这个变化：
@Test
publicvoidgivenMultiThread_whenBlockSync() {
ExecutorService service = Executors.newFixedThreadPool(3);
BaeldungSynchronizedBlocks synchronizedBlocks = newBaeldungSynchronizedBlocks();
IntStream.range(0, 1000)
.forEach(count ->
service.submit(synchronizedBlocks::performSynchronisedTask));
service.awaitTermination(100, TimeUnit.MILLISECONDS);
assertEquals(1000, synchronizedBlocks.getCount());
}
请注意，我们传递了一个this参数给同步代码块，这是那个监视器对象，代码块中的代码会在监视器对象上被同步。简单地说，每一个监视器对象只有一个线程能执行代码块中的代码。
当方法是静态方法时，我们会传递类名称来代替对象引用。并且这个Class对象将会是该同步代码块的监视器。
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());
}
5. 总结
在这篇文章中，我们看到了使用synchronized关键字来实现同步的不同方式。同时我们也探究了一个竞争(race condition) 是如何影响到我们的应用的以及同步是如何帮助我们避免的。 文章中的完整代码请去https://github.com/eugenp/tutorials/tree/master/core-java-concurrency