LFOSSA 技能焕新季即将启动： 7 折福利超前锁定，仅限前 30 名！

对象的共享：

• 要编写并发程序，关键在于：在访问共享的可变状态时需要进行正确的管理

可见性：     

/**
 * 可见性问题导致，程序运行结果不正确
 * 有可能由于编译器，处理器及运行时做一些重排序
 */
public class Novisibility {
	private static boolean ready;
	private static int number;
	
	private static class ReaderThread extends Thread{
		@Override
		public void run() {
			while (!ready){
				Thread.yield(); //主动让出cpu, 进入就绪队列
			}
			System.out.println(number);
		}
	}
	
	public static void main(String[] args) {
		new ReaderThread().start();
		number = 42;
		ready = true;
	}
}

• 失效数据：就如同上面的代码，没有同步的情况下可能产生错误的结果。

又如：

/**
 * get操作可能与最近set值不一致，产生数据失效
 */
@NotThreadSafe
public class MutableInteger {
	private int value;

	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}
}

/**
 * 将get, set同步化，可防止数据失效
 */
@ThreadSafe
public class MutableInteger {
	private int value;

	public synchronized int getValue() {
		return value;
	}

	public synchronized void setValue(int value) {
		this.value = value;
	}
}

• 非原子的64位操作：对于非volatile类型的long和double, jvm会将64位的读写操作分解为2个32位操作(java虚拟机栈中的操作数栈每个slot为32位)，对于这种变量在多线程读写操作下，有可能读取到某个值的高32位或某个值的低32位，建议在多线程环境下，对共享可变的long或double变量进行volatile声明。

• 加锁与可见性：加锁的含义不仅局限于互斥行为，还包括内存可见性。为了确保所有线程能看到共享可变变量的最新值，所有执行读写操作的线程必须在同一个锁上同步。

• Volatile变量：之前转载过一篇相关文章(http://my.oschina.net/indestiny/blog/208541), 当变量声明为volatile后，那么编译器或运行时会主要这个变量是共享的，不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或其他处理器不可见的地方，因此读取volatile变量总会返回最新的值。

      比较典型的用法：

private volatile boolean asleep;
...
while (!asleep){
    // do sth.
}

• 加锁机制既可以确保可见性又可以确保原子性，而volatile变量只可确保可见性，所以说volatile是一种轻量级同步机制；
• 满足以下所有条件时，可用volatile:

       1. 对变量的写入操作不依赖变量的当前值，或者能确保只有一个线程更新变量的值；

       2. 该变量不会与其他状态变量一起纳入不变性条件；

       3. 访问该变量不需要加锁。

发布与逸出：

• 发布对象：使对象能够在当前作用域之外被使用, 如：

//对共有静态变量的发布，集合内部的变量也会被发布
public static Set<Object> publishedObject;
public void init(){
    publishedObject = new HashSet<>();
}

//通过共有方法发布
private Object publishedObject;
public Object get(){
	return publishedObject;
}

/**
 * 通过发布类的内部实例
 * this引用被逸出
 */
public class ThisEscape {
	public ThisEscape(EventSource source){
		source.registerListener(new EventListener() {
			@Override
			public void onEvent(Event e) {
				// ThisEscape.this实例逸出，但此时该实例并没有构造完成
			}
		});
	}
}

安全的对象构造过程：

• 不要在构造过程中使this引用逸出，如上面的ThisEscape；

      可通过工厂方法避免this逸出：

/**
 * 通过工厂方法防止this逸出
 */
public class SafeListener {
	private final EventListener listener;
	private SafeListener(){
		listener = new EventListener() {
			@Override
			public void onEvent(Event e) {
				//do sth.
			}
		};
	}
	
	public static SafeListener newInstance(EventSource source){
		SafeListener safe = new SafeListener();
		source.registerListener(safe.listener);
		return safe;
	}
}

线程封闭：

• 线程封闭：在单线程内访问数据，不需要同步，这是实现线程安全最简单的方式。

• Ad-hoc线程封闭：维护线程封闭性的职责完全由程序实现来承担，它很脆弱，因为没有一种语言特性能将对象封闭到目标线程上。

• 栈封闭：是线程封闭的一种特例，在栈封闭中，只能通过局部变量才能访问对象。比Ad-hoc线程封闭更易维护，强壮。

• ThreadLocal类：一种维持线程封闭更规范的方法，它会为每个使用ThreadLocal变量的线程存放一份独立的副本，因此对于该变量线程之间不会相互干扰，你可以想ThreadLocal<T>想成Map<Thread, T>, 当线程终止时 ，这些值会作为垃圾回收。比如，多线程环境下，我们可以这样获取数据库连接：

private static ThreadLocal<Connection> connectionHolder = 
	new ThreadLocal<Connection>(){
		@Override
		protected Connection initialValue() {
			try {
				return DriverManager.getConnection("DB_URL");
			} catch (SQLException e) {
				e.printStackTrace();
			} 
			return null;
		}
	};
	
public static Connection getConnection(){
	//不同线程每次得到的Connection, 都是独立的备份
	return connectionHolder.get();
}

不变性：

• 不可变对象一定是线程安全的；

• 对象不可变应满足：

      1.对象创建后其状态不能修改；

      2.对象的所有域都是final类型；

      3.对象是正确创建的(在对象创建期间，this未逸出)。

• Final域：final类型的域不能修改(但其指向的引用对象可修改)，重新改造之前文章的CachedFactorizer:

/**
 * 不可变类：
 * 所有域都是final
 */
public class OneValueCache {
	private final BigInteger lastNumber;
	private final BigInteger[] lastFactors;
	
	public OneValueCache(BigInteger lastNumber, BigInteger[] lastFactors) {
		this.lastNumber = lastNumber;
		this.lastFactors = lastFactors;
	}
	
	public BigInteger[] getFactors(BigInteger i){
		if (lastNumber == null || ! lastNumber.equals(i)){
			return null;
		} else{
			return Arrays.copyOf(lastFactors, lastFactors.length);
		}
	}
}

/**
 * 使用Volatile类型发布不可变对象
 */
@ThreadSafe
public class VolatileCachedFactorizer implements Servlet {
	private volatile OneValueCache cache = new OneValueCache(null, null); //volatile保证每次写后最新值对其他线程可见
	@Override
	public void service(ServletRequest req, ServletResponse repo) {
		BigInteger i = extractFromRequest(req);
		BigInteger[] factors = cache.getFactors(i);
		if (factors == null) {
			factors = factor(i);
			cache = new OneValueCache(i, factors);
		}
		reponseTo(i, factors);
	}
}

安全发布：

• 不正确的发布：正确的对象被破坏：

/**
 * 多线程访问下，有可能出错，问题不在Holder本身，而在于未正确地发布，可将n声明为final，避免不正确发布
 */
public class Holder {
	private int n;
	
	public Holder(int n){
		this.n = n;
	}
	
	public void assertSanity(){
		if (n != n){
			throw new AssertionError("");
		}
	}
}

不可变对象与初始化安全性：

• 任何线程都可以在不需要额外同步地情况下安全地访问不可变对象，即使在发布这些对象时没有使用同步。

安全发布地常用模式：

• 一个正确构造的对象可以通过以下方式来安全地发布：

      1.在静态初始化函数中初始化一个对象引用;

      2.将对象的引用保存到volatile类型地域或AtomicReference对象中；

      3.将对象的引用保存到某个正确构造对象地final类型域中；

      4.将对象的引用保存到一个由锁保护的域中。

事实不可变对象：

• 如果对象从技术上来看是可变的，但其状态在发布后不会再改变，称这种对象为"事实不可变对象"。

• 在没有额外的同步的情况下，任何线程都可以安全地使用被安全发布的事实不可变对象。

可变对象：

• 可变对象：对象构造后，其状态可以发生改变；

• 对象的发布需求取决于它的可变性：

       1.不可变对象可以通过任意机制来发布；

       2.事实不可变对象必须通过安全方式来发布；

       3.可变对象必须通过安全方式来发布，并且必须是线程安全的或由某个锁保护起来。

安全地共享对象：

• 在并发程序中使用和共享对象时，可以使用一些使用的策略，包括：

      1.线程封闭。线程封闭的对象只能由一个线程拥有，对象被封闭在该线程中，只允许这个线程修改；

      2.只读共享。在没有同步的情况下，共享的只读对象可以由多个线程并发访问，但任何线程不能修改它。共享的只读对象包括不可变对象和事实不可变对象。

      3.线程安全共享。线程安全的对象在其内部实现同步，多个线程可以通过公有接口对其访问而不需进一步同步；

      4.保护对象。被保护对象只能通过持有特定锁来访问。保护对象包括封装在其他线程安全对象中的对象，以及已发布的并且由某个特定锁保护的对象。

不吝指正。