本章主要介绍如何编写线程安全的代码
1.线程安全
要编写线程安全的代码,核心在于要对状态访问操作进行管理,特别是共享的或者是可变的状态的访问。
当多个线程访问某个状态变量并且其中一个线程执行写入操作时,必须采用同步机制来协同这些线程对变量的访问。Java中的主要同步机制是关键字synchronized,它提供了一种独占的加锁方式,但同步这个术语还包括volatile类型的变量,显式锁以及原子变量。
所谓的线程安全性指的是,当多个线程访问某个类时,这个类始终都能表现出正确的行为。
无状态对象一定是线程安全的。
1.1原子性
先举一个非线程安全的例子
public class UnsafeCounting {
private int count = 0;
public int getCount() {
return count;
}
public int addCount() {
//非原子操作
return ++count;
}
}
代码测试:
public class UnsafeCountingTest {
private static final int NTHREAD = 10000;
@Test
public void test(){
UnsafeCounting unsafeCounting = new UnsafeCounting();
for(int i = 0 ; i < NTHREAD ; i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(unsafeCounting.addCount());
}
});
thread.start();
}
}
}
测试结果:
理论上最大数是10000;实际打印的最大数是9998;
UnsafeCounting并非线程安全的,因为++count并非原子的,实际上,它包含了三个独立的操作:读取count的值,将值加1,然后将计算结果写入count。这是一个“读取-修改-写入“的操作序列,并且其结果依赖于之前的状态。
在并发编程中这种由于不恰当的执行时序而出现不正确的结果叫 竞态条件。
最常见的竞态条件类型就是“先检查后执行”操作。
使用先检查后执行最常见的情况就是延迟初始化,比如:
package com.example.demo.thread;
public class LazyInitRace {
private Object instance = null;
public Object getInstance(){
if(instance == null){
instance = new Object();
}
return instance;
}
}
以上两个非线程安全的例子都包含一组需要原子方式执行的操作。
使用AtomicInteger类型的变量解决UnsafeCounting的非线程安全问题:
public class SafeCounting {
private final AtomicInteger count = new AtomicInteger(0);
public long getCount(){
return count.get();
}
public long addCount(){
return count.incrementAndGet();
}
}
在java.util.concurrent.atomic包中包含了一些原子变量类,用于实现在数值和对象引用上的原子状态转换。
1.2 加锁机制
尽管原子引用本身是线程安全的,但是如果还是存在竞态条件,还是可能产生错误的结果,比如:
import java.math.BigInteger;
import java.util.concurrent.atomic.AtomicReference;
public class UnSafeCaching {
private final AtomicReference<BigInteger> lastNumber = new AtomicReference<BigInteger>();
private final AtomicReference<BigInteger> lastFactors = new AtomicReference<BigInteger>();
public BigInteger service(BigInteger i){
if(i.equals(lastNumber.get())){
return lastFactors.get();
}else{
lastNumber.set(i);
lastFactors.set(factor(i));
return lastFactors.get();
}
}
private BigInteger factor(BigInteger i) {
return i.multiply(BigInteger.valueOf(100));
}
}
JAVA提供了一种内置的锁机制来支持原子性:同步代码块Synchronized Block。同步代码块包含两部分,一个作为锁的对象引用,一个作为由这个锁保护的代码块。
synchronized(lock){
//访问或修改由锁保护的共享状态
}
关键字synchronized修饰方法就是一种横跨整个方法体的同步代码块,该同步代码块的锁就是方法调用所在的对象。
每个java对象都可以用做一个实现同步的锁,这些锁被称为内置锁或者监视器锁Monitor Lock。
线程在进入同步代码块之前会自动获得锁,并且在退出同步代码块时自动释放锁。
java的内置锁是一种互斥锁,最多只有一个线程能够持有这种锁。
解决UnSafeCaching的并发问题,可以在service方法加上synchronized。
1.3重入
当某个线程请求试图获取一个已经由它自己持有的锁,那么这个请求会成功,这就是重入,重入意味着获取锁的操作的粒度是线程而不是调用,重入的一种实现方法是,为每一个锁关联一个获取计数值和一个所有者线程。
当计数值是0,这个锁就被认为是没有被任何线程持有,当线程请求一个未被持有的锁,JVM就会记下锁的持有者,并且将获取计数值设置为1,如果同一个线程再次获取这个锁,计数值将递增,而当线程退出同步代码块时,计数器会相应地递减,当计数器为0,这个锁会被释放。
package com.example.demo.thread;
public class Widget {
public synchronized void doSomething(){
}
}
package com.example.demo.thread;
public class LoggingWidget extends Widget{
public synchronized void doSomething(){
System.out.println(toString()+": calling doSomething");
super.doSomething();
}
}