线程安全性

几个概念

对象的状态

对象的状态指的是，存储在状态变量中的数据。对象的状态可能包括其他依赖对象的域。

什么时候会发生线程安全性问题？

如果有多个线程访问同一个共享的可变状态，就有可能产生线程安全性问题。

摘要

"要编写线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享的和可变的状态的访问。"

解决线程安全性的方法

如果当多个线程访问同一个可变的状态变量时，没有使用合适的同步，那么程序就会出现错误。有三种方式可以修复这个问题：

  . 不在线程之间共享该状态变量

  . 将状态变量修改为不可变的状态

  . 在访问状态变量时使用同步

如何设计线程安全的类

当设计线程安全的类时，良好的面向对象技术、不可修改性，以及明晰的不变性规范都能起到一定的帮助作用。

线程安全的对象

“在线程安全类的对象实例上执行的任何串行或并行操作都不会使对象处于无效状态。”

“在实际情况中，应尽可能地使用现有的线程安全对象来管理类的状态。与非线程安全对象相比，判断线程安全对象的可能状态及其状态转换情况要更为容易，从而也更容易维护和验证线程安全性。”

在线程安全类中封装了必要的同步机制，因此客户端无须进一步采用同步措施。

无状态对象

无状态对象一定是线程安全的。

竞态条件

最常见的竞态条件的类型就是-“先检查后执行”。

基于一种可能失效的观察结果来做出判断或执行某个计算。这种类型的竞态条件称为“先检查后执行”

原子操作

一组需要以原子方式执行的操作。

状态的一致性

要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量。

加锁机制

由于锁能使其保护的代码路径以串行方式来访问，因此可以通过锁来构造一些协议以实现对共享状态的独占访问。只要始终遵循这些协议，就能保证状态的一致性。

每个共享的和可变的变量都应该只由一个锁来保护，从而使维护人员知道是哪一个锁。

内置锁是可重入的

加锁约定

一种常见的加锁约定是，将所有的可变状态都封装在对象内部，并通过对象的内置锁对所有访问可变状态的代码路径进行同步，使得在该对象上不会发生并发访问。

对于每个包含多个变量的不变性条件，其中涉及的所有变量都需要由同一个锁来保护。

同步代码块中的代码路径要“足够短”

“要判断同步代码块的合理大小，需要在各种设计需求之间进行权衡，包括安全性、简单性和性能。”

通常，在简单性与性能直接存在着相互制约因素。当实现某个同步策略时，一定不要盲目地为了性能而牺牲简单性。（因为这可能破坏安全性）

当执行时间较长的计算或者可能无法快速完成的操作时，一定不要持有锁。

案例解析-仅对影响一致性的代码片段加锁，控制锁的粒度

package com;

import java.math.BigInteger;
import javax.servlet.*;

import net.jcip.annotations.*;

/**
 * CachedFactorizer
 * <p/>
 * Servlet that caches its last request and result
 *
 * @author Brian Goetz and Tim Peierls
 */
@ThreadSafe
public class CachedFactorizer extends GenericServlet implements Servlet {

    //此例子的一致性条件中包含：4个状态变量，分别是：lastNumber、lastFactors、hits、cacheHits
    //下面这四个皆为共享状态
    @GuardedBy("this") private BigInteger lastNumber;
    @GuardedBy("this") private BigInteger[] lastFactors;
    @GuardedBy("this") private long hits;
    @GuardedBy("this") private long cacheHits;

    public synchronized long getHits() {
        return hits;
    }

    public synchronized double getCacheHitRatio() {
        return (double) cacheHits / (double) hits;
    }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req); //对于没有操作共享变量的代码，无需进行加锁
        BigInteger[] factors = null;
        synchronized (this) {  //对影响一致性的代码，统一加锁
            ++hits;
            if (i.equals(lastNumber)) {
                ++cacheHits;
                factors = lastFactors.clone();
            }
        }
        if (factors == null) {
            factors = factor(i);
            synchronized (this) {  //对影响一致性的代码，统一加锁
                lastNumber = i;
                lastFactors = factors.clone();
            }
        }
        encodeIntoResponse(resp, factors);
    }

    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[]{i};
    }
}