专栏首页喔家ArchiSelf从构造函数看线程安全

从构造函数看线程安全

线程是编程中常用而且强大的手段,在使用过程中,我们经常面对的就是线程安全问题了。对于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
*/

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

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

  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

本文分享自微信公众号 - 喔家ArchiSelf(wireless_com),作者:老曹

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2017-04-16

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Amazon 的IoT之路(修正)

    众所周知,物联网(Internet of Things,IoT)可能是互联网时代开始以来企业面临的最大机遇。 Gartner 预测, 到2020年物联网上将有近...

    半吊子全栈工匠
  • Rethinking IoT

    在地铁阅读时光里读完了《重构物联网的未来》一书,稍感失望。该书的英文原著书名为:《Rethinking The Internet of Things-- A S...

    半吊子全栈工匠
  • IoT中的高音质音频设计

    音频是许多物联网应用不可或缺的组成部分, 包括消费品(如扬声器、耳机、可穿戴设备),医疗设备(如助听器),自动化工业控制应用、娱乐系统和汽车的信息娱乐设备等。

    半吊子全栈工匠
  • (68) 线程的基本协作机制 (下) / 计算机程序的思维逻辑

    本节继续上节的内容,探讨如何使用wait/notify实现更多的协作场景。 同时开始 同时开始,类似于运动员比赛,在听到比赛开始枪响后同时开始,下面,我们模拟...

    swiftma
  • 关闭线程的正确方法:“优雅”的中断

    线程在启动之后,正常的情况下会运行到任务完成,但是有的情况下会需要提前结束任务,如用户取消操作等。可是,让线程安全、快速和可靠地停止并不是件容易的事情,因为J...

    lyb-geek
  • C# 极限压缩 dotnet core 控制台发布文件

    每次发布 dotnet core 应用都会觉得发布文件太大,而如果使用极限压缩,用 CoreRT 能让发布的控制台文件到 5KB 左右,不需要带框架就能在其他设...

    林德熙
  • Java每日一练(2017/7/16)

    最新通知 ●回复"每日一练"获取以前的题目! ●【新】Ajax知识点视频更新了!(回复【学习视频】获取下载链接) ●答案公布时间:为每期发布题目的第二天 ★【新...

    Java学习
  • java高并发系列 - 第23天:JUC中原子类,一篇就够了

    JUC中的原子类都是都是依靠volatile、CAS、Unsafe类配合来实现的,需要了解的请移步: volatile与Java内存模型 java中的CAS J...

    路人甲Java
  • 你还在使用 try-catch-finally 关闭资源?

    作者:何甜甜在吗 链接:https://juejin.im/post/5b8f9fa05188255c6f1df755

    Java技术栈
  • java 线程池ThreadPoolExecutor 如何与 AsyncTask() 组合使用。

    转载请声明出处谢谢!https://cloud.tencent.com/developer/user/1148436/activities 这里主要使用Exec...

    林冠宏-指尖下的幽灵

扫码关注云+社区

领取腾讯云代金券