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

男娘i 2022-07-12 03:49 227阅读 0赞

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

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

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

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

见如下的lazy单例类：

Java代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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方法就会导致死锁。

[icon_star.png]: /images/20220711/11b96c94876940ee87e4c29d496e17d5.png