Race condition【竟态条件】(java并发编程实战第二章)

多线程环境下,无需调用方进行任何同步处理也能保证正确性的类是线程安全的类

 

无状态的对象是线程安全的。无状态是指没有成员变量。由于方法的局部变量都是在线程私有的栈中分配的,因此在一个线程中调用无状态对象的方法,不会影响到其他线程。

 

race condition: 正确性依赖于事件发生的相对时间。

check-and-act是race condition中的一种,指的是基于check的结果进行操作。由于check和act并非是原子的,进行act时check的结果可能已经无效,那么基于check所进行的act就可能带来问题。

见如下的lazy单例类:

Java代码  

  1. public class LazyInitRace {  
  2.     private static ExpensiveObject instance = null;  
  3.     public static ExpensiveObject getInstance() {  
  4.         // if语句是一个check-and-act操作  
  5.         if (instance == null) {  
  6.             instance = new ExpensiveObject();  
  7.         }  
  8.         return instance;  
  9.     }  
  10. }  

 这是一个check-and-act的典型例子:首先判断instance是否为null,如果是就创建ExpensiveObject对象,否则直接返回instance。但是判断和创建并非原子操作,假设线程1判断出instance为null,要是另一个线程紧接着创建了ExpensiveObject对象,那么线程1的判断就失效了,基于判断结果所进行的创建操作就会导致程序中存在多个ExpensiveObject对象–这违背了单例模式的初衷。

 

Read‐modify‐write也是race condition中的一种,指的是读取某个变量的值,修改后写回。这显然不是一个原子操作,如果B线程在A线程read之后write之前修改了变量的值,那么A线程read的结果就失效了,基于read所做的modify就可能带来问题。

见如下的servlet:

Java代码  

  1. public class CountingFactorizer implements Servlet {  
  2.     private final long count = 0;  
  3.     public void service(ServletRequest req, ServletResponse resp) {  
  4.         BigInteger i = extractFromRequest(req);  
  5.         BigInteger[] factors = factor(i);  
  6.         // // 自增语句是一个Read‐modify‐write操作  
  7.         count++;  
  8.         encodeIntoResponse(resp, factors);  
  9.     }  
  10. }  

 

使用java提供的同步机制,将check-and-act或者Read‐modify‐write转换为原子操作,则可以避免race condition造成的错误。

使用同步机制改进LazyInitRace和CountingFactorizer类,使之成为线程安全的类:

Java代码  

  1. public class LazyInitRace {  
  2.     private static ExpensiveObject instance = null;  
  3.   
  4.     public static ExpensiveObject getInstance() {  
  5.         // 使用synchronized将check-and-act操作转换为原子操作  
  6.         if (instance == null) {  
  7.             synchronized (LazyInitRace.class) {  
  8.                 if (instance == null) {  
  9.                     instance = new ExpensiveObject();  
  10.                 }  
  11.             }  
  12.         }  
  13.         return instance;  
  14.     }  
  15. }  
  16.   
  17. public class CountingFactorizer implements Servlet {  
  18.     private final AtomicLong count = new AtomicLong(0);  
  19.     public void service(ServletRequest req, ServletResponse resp) {  
  20.         BigInteger i = extractFromRequest(req);  
  21.         BigInteger[] factors = factor(i);  
  22.         // 使用long对应的原子类AtomicLong,将Read‐modify‐write操作转换为原子操作  
  23.         count.incrementAndGet();  
  24.         encodeIntoResponse(resp, factors);  
  25.     }  
  26. }  

 

对于只有一个成员变量的对象,成员的状态就是对象的状态。如果涉及到该成员的操作都是原子的,那么该类就是一个线程安全的类。比如以上的LazyInitRace类,其只有一个成员变量instance,且涉及instance的操作是原子的,因此LazyInitRace类是一个线程安全的类。

是否可以类推出,只要类的每一个成员变量的操作都是原子的,类就是线程安全的?不行。

因为每一个成员的操作都是原子的,不能保证所有涉及到成员的操作整体上是原子的。例如:

Java代码  

  1. public class UnsafeCachingFactorizer implements Servlet {  
  2.     private final AtomicReference<BigInteger> lastNumber = new AtomicReference<BigInteger>();  
  3.     private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<BigInteger[]>();  
  4.     public void service(ServletRequest req, ServletResponse resp) {  
  5.         BigInteger i = extractFromRequest(req);  
  6.         // 优先使用缓存  
  7.         if (i.equals(lastNumber.get()))  
  8.             encodeIntoResponse(resp, lastFactors.get() );  
  9.         else {  
  10.             BigInteger[] factors = factor(i);  
  11.             // 将最后一次的计算结果缓存起来  
  12.             lastNumber.set(i);  
  13.             lastFactors.set(factors);  
  14.             encodeIntoResponse(resp, factors);  
  15.         }  
  16.     }  
  17. }  

 UnsafeCachingFactorizer类的2个成员lastNumber和lastFactors的set()和get()方法是原子的,但是该类不是线程安全的。因为从整体上看,2次写入和2次读取都不是同时进行的,UnsafeCachingFactorizer类仍然存在race condition.

 

java的synchronized机制使用的锁是可重入锁,即同一个线程可以多次申请持有同一把锁而不会引起死锁。假设A线程持有lock,那么如果B线程申请lock锁,B线程就会被阻塞。但是如果A线程再次申请已经持有的lock锁,该申请将获得通过,这就是所谓的同一线程可多次获取同一把锁。作为锁的对象,不仅需要标识锁的所有者,也需要标识所有者持有的计数。如果所有者线程刚刚申请到锁,则计数器的值为1,每重新获取一次,计数器的值加1,每退出一个同步代码块,计数器的值减1. 当计数器的值减为0时,所有者线程才释放锁。可重入锁的设计是为了防止因申请已持有的锁而造成死锁,例如:

Java代码  

  1. public class Widget {  
  2.     public synchronized void doSomething() {  
  3.         …  
  4.     }  
  5. }  
  6. public class LoggingWidget extends Widget {  
  7.     public synchronized void doSomething() {  
  8.         System.out.println(toString() + “: calling doSomething”);  
  9.         super.doSomething();  
  10.     }  
  11. }  

 如果java中的锁不是可重入的,那么调用LoggingWidget对象的doSomething方法就会导致死锁。

    原文作者:哈哈哈哈哈哈哈111
    原文地址: https://blog.csdn.net/u012572955/article/details/54947897
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞