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

1. 线程安全性

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

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

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

​ —— Java并发编程实战

2. 示例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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):

TIM截图20181024221940.png

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

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

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

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

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

TIM截图20181024223118.png

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

1
Total time is 191.81470131874084

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

1
2
3
4
5
6
7
8
9
10
11
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) {
synchronized (this) {
++count;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

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

1
Total time is 2.9431087970733643

3. 总结

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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方法实现同步即可:

1
2
3
4
5
6
public synchronized ExpensiveObject getInstance() {
if (instance == null) {
return new ExpensiveObject();
}
return instance;
}

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

Pushy wechat
欢迎订阅我的微信公众号