谈谈 Java 并发编程中的线程安全性

1. 线程安全性

在单线程程序中，我们并不需要去考虑线程的安全性。但是在多线程程序中，由于多个线程要共享相同的内存地址空间，并且是并发运行，因此它们可能会访问或修改其他线程正在使用的变量。

所以，在这种情况下，可能会引发不正确的结果，在并发编程中，称之为“竞态条件”。

在并发编程中，这种由于不恰当的执行时序而引发不正确的结果情况叫做竞态条件。—— Java并发编程实战

2. 示例

例如，我们想在 Servlet 中统计客户端的请求个数。这一点都不难，不就是在客户端每次请求时将count值自加 1 嘛：

@WebServlet(name = "SafeFactorizer", urlPatterns = "/*", loadOnStartup = 1)
public class SafeFactorizer extends HttpServlet {
    
    private long count = 0;
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) {
        ++count;
        System.out.println("Now count is " + count);
        
        // 模拟耗时的IO操作
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    
}

但是，++count看似是一个紧凑的单个操作，其实它包含了三个独立的操作：

• 读取value值
• 将value的值加1
• 将计算的结果写入value

可以看到，这并不是一个原子操作（不可分，连续完成的）。如果客户端的请求达到一定数目，很有可能统计到不正确的数值。我们可以模拟999个客户端请求一下，这里使用Python多线程模拟了999个请求，并打印出所有请求花费的总时间t2-t1：

def fun():
    requests.get('http://localhost:8080')
    
if __name__ == '__main__':
    threads = []       # 存放已经创建线程实例的列表
    for i in range(1, 1000):
        t = threading.Thread(target=fun)
        threads.append(t)
        
    t1 = time.time()   # 请求开始时间
    for t in threads:
        t.setDaemon(True)
        t.start() 
    t.join() 
    
    t2 = time.time()   # 请求结束时间
    print("Total time is {}".format(t2 - t1))

可以看到服务端中最后打印出的count值为989，和预期的客户端999个请求的结果不相同。说明由于竞态条件的问题，导致统计出现了错误的结果（预期应该统计出999）：

而且在客户端的控制台上，也得到全部请求花费的总时间：

Total time is 2.623112201690674  # 客户端打印结果

你可能要问了，这还不简单吗？Java有内置锁，我们给service方法加上一个synchronized关键字实现同步不就可以解决了吗。当然可以，我们可以试试：

 @Override
 protected synchronized void service(HttpServletRequest req, HttpServletResponse resp) {
 	...
 }

这时候，我们来尝试模拟使用999客户端来请求，可以看到结果的确符合了我们的期望：

但是客户端花费的时间和没使用同步前相差的不是一丁半点：

Total time is 191.81470131874084

这种同步机制确实使得确保service方法的线程安全性，但是在这种情况下：同一时刻只能有一个线程可以执行service方法，这样就背离了 Servlet 框架同时处理多个请求的初衷。幸运的是，我们可以通过缩小同步代码块的作用范围，可以很容易地做到既确保Servlet的并发性，同时又维护线程的安全性：

@Override
 protected void service(HttpServletRequest req, HttpServletResponse resp) {
    synchronized (this) {
        ++count;
    }
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
 }

现在，我们看下客户端的全部请求花费的时间。可以看到，和没有使用同步加锁机制所花费的时间大致一样：

Total time is 2.9431087970733643

3. 总结

除了像上面那种读写——修改——写入操作，还有例如单例模式的懒汉式实现方式：

public class LazyInitRace {

    private ExpensiveObject instance = null;
    
    private LazyInitRace() {}

    public ExpensiveObject getInstance() {
        if (instance == null) {
            return new ExpensiveObject();
        }
        return instance;
    }
}

可以看到，我们在getInstance方法中， 做了“先检查后执行”的操作。在并发编程中，把这些操作称之为复合操作：包含了一组必须以原子方式执行的操作以确保线程的安全性。

我们考虑一种情况：当线程A执行了getInstance方法， 检查到instance为空，因而创建了新的ExpensiveObject对象；此时，线程B也执行了getInstance方法，但是此时线程检查出的instance是否为空，取决于不可预测的时序（线程调度方式、A创建对象花费时间），如果线程B也检查到instance为空。那么在这两次调用getInstance方法将会得到不同的结果，而不是单一的实例对象了。

解决的方式也非常容易，只需要让getInstance方法实现同步即可：

public synchronized ExpensiveObject getInstance() {
    if (instance == null) {
        return new ExpensiveObject();
    }
    return instance;
}

因此，在并发编程中， 我们应该确保操作的原子性。如果某些复合操作不具备原子性，我们则可以使用synchronized 加锁同步机制来实现某些复合操作的原子性。

---