老曹：从构造函数看线程安全

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

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

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

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

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

 
 
 
    
  
  
  
  1. // HasID.java  
    2. 
  
  
  
  2. public interface HasID { 
    3. 
  
  
  
  3.   int getID(); 
    4. 
  
  
  
  4. } 
    5.

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

 
 
 
    
  
  
  
  1. // StaticIDField.java 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. public class StaticIDField implements HasID { 
    4. 
  
  
  
  4.   private static int counter = 0; 
    5. 
  
  
  
  5.   private int id = counter++; 
    6. 
  
  
  
  6.   public int getID() { return id; } 
    7. 
  
  
  
  7. } 
    8.

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

 
 
 
    
  
  
  
  1. // IDChecker.java 
    2. 
  
  
  
  2. import java.util.*; 
    3. 
  
  
  
  3. import java.util.function.*; 
    4. 
  
  
  
  4. import java.util.stream.*; 
    5. 
  
  
  
  5. import java.util.concurrent.*; 
    6. 
  
  
  
  6. import com.google.common.collect.Sets; 
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8. public class IDChecker { 
    9. 
  
  
  
  9.   public static int SIZE = 100000; 
    10. 
  
  
  
  10.   static class MakeObjects 
    11. 
  
  
  
  11.   implements Supplier> { 
    12. 
  
  
  
  12.     private Supplier gen; 
    13. 
  
  
  
  13.     public MakeObjects(Supplier gen) { 
    14. 
  
  
  
  14.       this.gen = gen; 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16.     @Override 
    17. 
  
  
  
  17.     public List get() { 
    18. 
  
  
  
  18.       return 
    19. 
  
  
  
  19.         Stream.generate(gen) 
    20. 
  
  
  
  20.           .limit(SIZE) 
    21. 
  
  
  
  21.           .map(HasID::getID) 
    22. 
  
  
  
  22.           .collect(Collectors.toList()); 
    23. 
  
  
  
  23.     } 
    24. 
  
  
  
  24.   } 
    25. 
  
  
  
  25.   public static void test(Supplier gen) { 
    26. 
  
  
  
  26.     CompletableFuture> 
    27. 
  
  
  
  27.       groupA = CompletableFuture 
    28. 
  
  
  
  28.         .supplyAsync(new MakeObjects(gen)), 
    29. 
  
  
  
  29.       groupB = CompletableFuture 
    30. 
  
  
  
  30.         .supplyAsync(new MakeObjects(gen)); 
    31. 
  
  
  
  31.     groupA.thenAcceptBoth(groupB, (a, b) -> { 
    32. 
  
  
  
  32.       System.out.println( 
    33. 
  
  
  
  33.         Sets.intersection( 
    34. 
  
  
  
  34.           Sets.newHashSet(a), 
    35. 
  
  
  
  35.           Sets.newHashSet(b)).size()); 
    36. 
  
  
  
  36.     }).join(); 
    37. 
  
  
  
  37.   } 
    38. 
  
  
  
  38. } 
    39.

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

 
 
 
    
  
  
  
  1. // TestStaticIDField.java 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. public class TestStaticIDField { 
    4. 
  
  
  
  4.   public static void main(String[] args) { 
    5. 
  
  
  
  5.     IDChecker.test(StaticIDField::new); 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. /* Output: 
    9. 
  
  
  
  9. 47643 
    10. 
  
  
  
  10. */ 
    11.

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

 
 
 
    
  
  
  
  1. // GuardedIDField.java 
    2. 
  
  
  
  2. import java.util.concurrent.atomic.*; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. public class GuardedIDField implements HasID { 
    5. 
  
  
  
  5.   private static AtomicInteger counter = 
    6. 
  
  
  
  6.     new AtomicInteger(); 
    7. 
  
  
  
  7.   private int id = counter.getAndAdd(1); 
    8. 
  
  
  
  8.   public int getID() { return id; } 
    9. 
  
  
  
  9.   public static void main(String[] args) { 
    10. 
  
  
  
  10.     IDChecker.test(GuardedIDField::new); 
    11. 
  
  
  
  11.   } 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. /* Output: 
    14. 
  
  
  
  14. 0 
    15. 
  
  
  
  15. */ 
    16.

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

 
 
 
    
  
  
  
  1. // SharedConstructorArgument.java 
    2. 
  
  
  
  2. import java.util.concurrent.atomic.*; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. interface SharedArg { 
    5. 
  
  
  
  5.   int get(); 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8. class Unsafe implements SharedArg { 
    9. 
  
  
  
  9.   private int i = 0; 
    10. 
  
  
  
  10.   public int get() { return i++; } 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. class Safe implements SharedArg { 
    14. 
  
  
  
  14.   private static AtomicInteger counter = 
    15. 
  
  
  
  15.     new AtomicInteger(); 
    16. 
  
  
  
  16.   public int get() { 
    17. 
  
  
  
  17.     return counter.getAndAdd(1); 
    18. 
  
  
  
  18.   } 
    19. 
  
  
  
  19. } 
    20. 
  
  
  
  20.  
    21. 
  
  
  
  21. class SharedUser implements HasID { 
    22. 
  
  
  
  22.   private final int id; 
    23. 
  
  
  
  23.   public SharedUser(SharedArg sa) { 
    24. 
  
  
  
  24.     id = sa.get(); 
    25. 
  
  
  
  25.   } 
    26. 
  
  
  
  26.   @Override 
    27. 
  
  
  
  27.   public int getID() { return id; } 
    28. 
  
  
  
  28. } 
    29. 
  
  
  
  29.  
    30. 
  
  
  
  30. public class SharedConstructorArgument { 
    31. 
  
  
  
  31.   public static void main(String[] args) { 
    32. 
  
  
  
  32.     Unsafe unsafe = new Unsafe(); 
    33. 
  
  
  
  33.     IDChecker.test(() -> new SharedUser(unsafe)); 
    34. 
  
  
  
  34.     Safe safe = new Safe(); 
    35. 
  
  
  
  35.     IDChecker.test(() -> new SharedUser(safe)); 
    36. 
  
  
  
  36.   } 
    37. 
  
  
  
  37. } 
    38. 
  
  
  
  38. /* Output: 
    39. 
  
  
  
  39. 47747 
    40. 
  
  
  
  40. 0 
    41. 
  
  
  
  41. */ 
    42.

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

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

 
 
 
    
  
  
  
  1. // SynchronizedConstructor.java 
    2. 
  
  
  
  2. import java.util.concurrent.atomic.*; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. class SyncConstructor implements HasID { 
    5. 
  
  
  
  5.   private final int id; 
    6. 
  
  
  
  6.   private static Object constructorLock = new Object(); 
    7. 
  
  
  
  7.   public SyncConstructor(SharedArg sa) { 
    8. 
  
  
  
  8.     synchronized(constructorLock) { 
    9. 
  
  
  
  9.       id = sa.get(); 
    10. 
  
  
  
  10.     } 
    11. 
  
  
  
  11.   } 
    12. 
  
  
  
  12.   @Override 
    13. 
  
  
  
  13.   public int getID() { return id; } 
    14. 
  
  
  
  14. } 
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16. public class SynchronizedConstructor { 
    17. 
  
  
  
  17.   public static void main(String[] args) { 
    18. 
  
  
  
  18.     Unsafe unsafe = new Unsafe(); 
    19. 
  
  
  
  19.     IDChecker.test(() -> new SyncConstructor(unsafe)); 
    20. 
  
  
  
  20.   } 
    21. 
  
  
  
  21. } 
    22. 
  
  
  
  22. /* Output: 
    23. 
  
  
  
  23. 0 
    24. 
  
  
  
  24. */ 
    25.

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

 
 
 
    
  
  
  
  1. // SynchronizedFactory.java 
    2. 
  
  
  
  2. import java.util.concurrent.atomic.*; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. class SyncFactory implements HasID { 
    5. 
  
  
  
  5.   private final int id; 
    6. 
  
  
  
  6.   private SyncFactory(SharedArg sa) { 
    7. 
  
  
  
  7.     id = sa.get(); 
    8. 
  
  
  
  8.   } 
    9. 
  
  
  
  9.   @Override 
    10. 
  
  
  
  10.   public int getID() { return id; } 
    11. 
  
  
  
  11.   public static synchronized 
    12. 
  
  
  
  12.   SyncFactory factory(SharedArg sa) { 
    13. 
  
  
  
  13.     return new SyncFactory(sa); 
    14. 
  
  
  
  14.   } 
    15. 
  
  
  
  15. } 
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17. public class SynchronizedFactory { 
    18. 
  
  
  
  18.   public static void main(String[] args) { 
    19. 
  
  
  
  19.     Unsafe unsafe = new Unsafe(); 
    20. 
  
  
  
  20.     IDChecker.test(() -> 
    21. 
  
  
  
  21.       SyncFactory.factory(unsafe)); 
    22. 
  
  
  
  22.   } 
    23. 
  
  
  
  23. } 
    24. 
  
  
  
  24. /* Output: 
    25. 
  
  
  
  25. 0 
    26. 
  
  
  
  26. */ 
    27.

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

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

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

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

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

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

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

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

【本文来自专栏作者“老曹”的原创文章，作者微信公众号：喔家ArchiSelf,id:wrieless-com】

网页名称：老曹：从构造函数看线程安全
本文来源：http://www.shufengxianlan.com/qtweb/news23/374273.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

用户体验知识

分类信息网站

网站运营　　 　广西弘博建站　　 　德阳做网站　　 　成都富士康招工　　 　成都导视系统设计　　 　广安做网站　　 　广汉做网站　　 　成都商城app开发　　 　成都外贸网站建设　　 　成都关键词SEO优化　　 　谷歌推广　　 　外贸网站设计方案　　 　绵阳服务器托管　　 　做网站　　 　达州托管服务器　　 　国泰民安消防　　 　企业网站设计　　 　四川雅安服务器托管　　 　成都SEO优化　　 　绵阳服务器托管