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 oid 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加锁同步机制来实现某些复合操作的原子性。
