从构造函数看线程安全

线程是编程中常用而且强大的手段，在使用过程中，我们经常面对的就是线程安全问题了。对于Java中常见的数据结构而言，一般的，ArrayList是非线程安全的，Vector是线程安全的；HashMap是非线程安全的，HashTable是线程安全的；StringBuilder是非线程安全的，StringBuffer是线程安全的。

然而，判断代码是否线程安全，不能够想当然，例如Java 中的构造函数是否是线程安全的呢？ 

自己从第一感觉来看，构造函数应该是线程安全的，如果一个对象没有初始化完成，怎么可能存在竞争呢？ 甚至在Java 的语言规范中也谈到，没有必要将constructor 置为synchronized，因为它在构建过程中是锁定的，其他线程是不可能调用还没有实例化好的对象的。

但是，当我读过了Bruce Eckel 的博客文章，原来构造函数也并不是线程安全的，本文中的示例代码和解释全部来自Bruce Eckel 的那篇文章。

演示的过程从 定义一个接口开始：

// HasID.javapublic interface HasID {  int getID();}

有各种方法可以实现这个接口，先看看静态变量方式的实现：

// StaticIDField.javapublic class StaticIDField implements HasID {  private static int counter = 0;  private int id = counter++;  public int getID() { return id; }}

这是一个简单而无害的类，再构造一个用于并行调用的测试类：

// IDChecker.javaimport java.util.*;import java.util.function.*;import java.util.stream.*;import java.util.concurrent.*;import com.google.common.collect.Sets;public class IDChecker {  public static int SIZE = 100000;  static class MakeObjects  implements Supplier<List<Integer>> {    private Supplier<HasID> gen;    public MakeObjects(Supplier<HasID> gen) {      this.gen = gen;    }    @Override    public List<Integer> get() {      return        Stream.generate(gen)          .limit(SIZE)          .map(HasID::getID)          .collect(Collectors.toList());    }  }  public static void test(Supplier<HasID> gen) {    CompletableFuture<List<Integer>>      groupA = CompletableFuture        .supplyAsync(new MakeObjects(gen)),      groupB = CompletableFuture        .supplyAsync(new MakeObjects(gen));    groupA.thenAcceptBoth(groupB, (a, b) -> {      System.out.println(        Sets.intersection(          Sets.newHashSet(a),          Sets.newHashSet(b)).size());    }).join();  }}

其中 MakeObjects 是一个 Supplier 通过get（）方法产生一个 List. 这个 List 从 每个HasID 对象中得到一个ID。test() 方法创建了两个并行的CompletableFutures 来运行MakeObjects suppliers, 然后就每个结果使用Guava库的Sets.intersection() 来找出两个List中有多少个共有的ID。现在，测试一下多个并发任务调用这个StaticIDField类的结果：

// TestStaticIDField.javapublic class TestStaticIDField {  public static void main(String[] args) {    IDChecker.test(StaticIDField::new);  }}/* Output:47643*/

有大量的重复值，显然 static int 不是线程安全的，需要用AtomicInteger 尝试一下：

// GuardedIDField.javaimport java.util.concurrent.atomic.*;public class GuardedIDField implements HasID {  private static AtomicInteger counter =    new AtomicInteger();  private int id = counter.getAndAdd(1);  public int getID() { return id; }  public static void main(String[] args) {    IDChecker.test(GuardedIDField::new);  }}/* Output:0*/

通过构造函数的参数来共享状态同样是对线程安全敏感的：

// SharedConstructorArgument.javaimport java.util.concurrent.atomic.*;interface SharedArg {  int get();}class Unsafe implements SharedArg {  private int i = 0;  public int get() { return i++; }}class Safe implements SharedArg {  private static AtomicInteger counter =    new AtomicInteger();  public int get() {    return counter.getAndAdd(1);  }}class SharedUser implements HasID {  private final int id;  public SharedUser(SharedArg sa) {    id = sa.get();  }  @Override  public int getID() { return id; }}public class SharedConstructorArgument {  public static void main(String[] args) {    Unsafe unsafe = new Unsafe();    IDChecker.test(() -> new SharedUser(unsafe));    Safe safe = new Safe();    IDChecker.test(() -> new SharedUser(safe));  }}/* Output:477470*/

这里，SharedUser的构造函数共享了相同的参数，SharedUser 理所当然的使用了这些参数，构造函数引起了冲突，而自身并不知道失控了。

Java 中并不支持对构造函数synchronized，但实际上可以实现一个synchronized 块的，例如：

// SynchronizedConstructor.javaimport java.util.concurrent.atomic.*;class SyncConstructor implements HasID {  private final int id;  private static Object constructorLock = new Object();  public SyncConstructor(SharedArg sa) {    synchronized(constructorLock) {      id = sa.get();    }  }  @Override  public int getID() { return id; }}public class SynchronizedConstructor {  public static void main(String[] args) {    Unsafe unsafe = new Unsafe();    IDChecker.test(() -> new SyncConstructor(unsafe));  }}/* Output:0*/

这样，就是线程安全的了。另一种方式是避免构造函数的集成，通过一个静态工厂的方法来生成对象：

// SynchronizedFactory.javaimport java.util.concurrent.atomic.*;class SyncFactory implements HasID {  private final int id;  private SyncFactory(SharedArg sa) {    id = sa.get();  }  @Override  public int getID() { return id; }  public static synchronized  SyncFactory factory(SharedArg sa) {    return new SyncFactory(sa);  }}public class SynchronizedFactory {  public static void main(String[] args) {    Unsafe unsafe = new Unsafe();    IDChecker.test(() ->      SyncFactory.factory(unsafe));  }}/* Output:0*/

这样通过工厂方法来实现加锁就可以安全了。

这样的结果对于老码农来说，并不意外，因为线程安全取决于那三竞争条件的成立：

1. 两个处理共享变量

2. 至少一个处理会对变量进行修改

3. 一个处理未完成前另一个处理会介入进来

示例程序中主要是用锁来实现的，这一点上，erlang实际上具有着先天的优势。纸上得来终觉浅，终于开始在自己的虚拟机上开始安装Java 8 了，否则示例程序都跑不通了。对完成线程安全而言————

规避一，没有共享内存，就不存在竞态条件了，例如利用独立进程和actor模型。

规避二，比如C++中的const，scala中的val，Java中的immutable

规避三, 不介入，使用协调模式的线程如coroutine等，也可以使用表示不便介入的标识——锁、mutex、semaphore，实际上是使用中的状态令牌。

最后，简单粗暴地说， share nothing 基本上可以从根本上解决线程安全吧。

参考阅读：

http://bruceeckel.github.io/ 

https://www.ibm.com/developerworks/cn/java/j-jtp09263/ 

http://blog.csdn.net/wirelesscom/article/details/44150053 

http://blog.csdn.net/wirelesscom/article/details/42550241