第一章：并发编程-线程安全性

本章主要介绍如何编写线程安全的代码

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();
	}

}