正文

从构造函数看线程安全

半吊子全栈工匠  半吊子全栈工匠  2022-08-28  491

关键词：

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

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

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

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

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

// HasID.java

public interface HasID {
  int getID();
}

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

// StaticIDField.java

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

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

// IDChecker.java
import 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.java

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

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

// GuardedIDField.java
import 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.java
import 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:
47747
0
*/

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

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

// SynchronizedConstructor.java
import 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.java
import 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
*/

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

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

两个处理共享变量
至少一个处理会对变量进行修改
一个处理未完成前另一个处理会介入进来

示例程序中主要是用锁来实现的，这一点上，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

C# 静态构造函数线程安全吗？

】C#静态构造函数线程安全吗？【英文标题】：IstheC#staticconstructorthreadsafe?【发布时间】：2010-09-0515:29:52【问题描述】：换句话说，这个Singleton实现线程安全吗：publicclassSingletonprivatestaticSingletoninstance;privateSingleton()staticSingleton()ins... 查看详情

求解惑：关于多线程并发环境下构造函数的线程安全(代码片段)

文章目录在构造期间不要泄露this指针我的“犯忌”代码以及诡辩我解释不了的代码在构造期间不要泄露this指针对象构造要做到线程安全，惟一的要求是在构造期间不要泄露this指针，即1、不要在构造函数中注册任何回调2... 查看详情

静态函数范围对象的构造是线程安全的吗？

】静态函数范围对象的构造是线程安全的吗？【英文标题】：Isconstructionofstaticfunction-scopeobjectthread-safe?【发布时间】：2010-12-3022:23:26【问题描述】：假设我有一个函数尝试使用此代码保护全局计数器：staticMyCriticalSectionWrapperlock;l... 查看详情

在类构造函数线程中启动 std::thread 是不是安全？

】在类构造函数线程中启动std::thread是不是安全？【英文标题】：Isstartinganstd::threadinaclassconstructorthreadsafe?在类构造函数线程中启动std::thread是否安全？【发布时间】：2019-12-0120:53:31【问题描述】：所以我有一个类似这样的代码（... 查看详情

线程安全类是不是应该在其构造函数的末尾有一个内存屏障？

】线程安全类是不是应该在其构造函数的末尾有一个内存屏障？【英文标题】：Shouldthread-safeclasshaveamemorybarrierattheendofitsconstructor?线程安全类是否应该在其构造函数的末尾有一个内存屏障？【发布时间】：2016-12-1707:53:10【问题描... 查看详情

C++ 中的默认构造函数是线程安全的吗？

】C++中的默认构造函数是线程安全的吗？【英文标题】：Isthedefaultconstructorthread-safeinC++?【发布时间】：2016-05-2010:20:53【问题描述】：classlog_String//Theseareprivate!std::vector<std::string>list;std::mutexm;log_String&operator=(constlog_String& 查看详情

c++如何在构造函数中启动一个线程，从命名管道读取数据？

想用构造函数CFetionPipe()启动线程ReadThread，它循环调用CFetionPipe类的函数ReadString()，对收到的管道消息进行处理和响应。CFetionPipe类在千里眼的回答贴出来了。线程ReadThread函数要实例化CFetionPipe类，才能使用ReadString()函数，而实例... 查看详情

从 C++ 中的多个线程调用 Qt 中小部件类的信号函数是不是安全？

】从C++中的多个线程调用Qt中小部件类的信号函数是不是安全？【英文标题】：IsitsafetocallasignalfunctionofawidgetclassinQtfrommultiplethreadsinC++?从C++中的多个线程调用Qt中小部件类的信号函数是否安全？【发布时间】：2013-08-2800:17:13【问... 查看详情

单列模式对比(代码片段)

　　单例模式。构造函数是私有的，通过一个共有的成员函数还调用这个构造函数，在多线程环境下，还需要对这个成员函数进行加锁。下面是4种单例的创建方式，最安全也最好的是第4种，使用内部类的方式。1、懒汉式单例，... 查看详情

qt入门教程qobject篇重入性和线程安全(代码片段)

...个文档中，术语*“重入”和“线程安全*”用于标记类和函数，以指示如何在多线程应用程序中使用它们：线程安全函数可以从多个线程同时调用，即使调用使用共享数据也是如此，因为对共享数据的所有引用都是序列化的。也... 查看详情

什么时候在构造函数和析构函数中调用 this-> 是安全的

】什么时候在构造函数和析构函数中调用this->是安全的【英文标题】：Whenisitsafetocallthis->inconstructoranddestructor【发布时间】：2015-07-2707:51:07【问题描述】：到目前为止，我还没有找到确切的答案。什么时候从对象中调用this-&a... 查看详情

从 ViewModel 构造函数 Xamarin.Forms 调用异步方法

】从ViewModel构造函数Xamarin.Forms调用异步方法【英文标题】：CallingAsynchronousmethodfromViewModelConstructorXamarin.Forms【发布时间】：2017-10-1820:01:12【问题描述】：我在a-z中找不到关于如何以安全的方式从构造函数调用异步方法的直接示例... 查看详情

Files.copy 是 Java 中的线程安全函数吗？

...多次运行，每次都由不同线程中的对象运行。它在对象的构造函数中被调用，但我有逻辑只在文件不存在时复制文件（意思是，它检查以确保其他并行实例之一尚未创建它）。查看详情

java实现线程安全的单例模式

...例。　　以上三个要点提示着我们的代码编写需要注意，构造函数必须私有，否则在其他类中便可以调用构造函数查看详情

在破坏调用期间从另一个线程未定义的行为调用对象上的方法？(代码片段)

...ndard（12.7.4）说：成员函数，包括虚函数（10.3），可以在构造或销毁期间调用（12.6.2）。当从构造函数或析构函数直接或间接调用虚函数时，包括在构造或销毁类的非静态数据成员期间，以及调用所适用的对象是正在构造的对象... 查看详情

源码阅读(39)：java中线程安全的queuedeque结构——linkedtransferqueue(代码片段)

...ransferQueue（1）》2.3、LinkedTransferQueue的主要属性和构造函数LinkedTransferQueue队列集合主要包括以下关键属性：publicclassLinkedTransferQueue<E>extendsAbstractQueue<E>implementsTransferQueue<E>,java.io.Serializable//该节点指向单向... 查看详情

源码阅读(39)：java中线程安全的queuedeque结构——linkedtransferqueue(代码片段)

赋值复制构造函数和构造函数&异常安全的赋值

异常安全的赋值需要注意，复制赋值和复制构造，相兼容。赋值时候，要带上自检查。查看详情