对象的共享：

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

可见性：

/** * 可见性问题导致，程序运行结果不正确 * 有可能由于编译器，处理器及运行时做一些重排序 */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值不一致，产生数据失效 */@NotThreadSafepublic class MutableInteger {	private int value;	public int getValue() {		return value;	}	public void setValue(int value) {		this.value = value;	}}

可做如下修改：

/** * 将get, set同步化，可防止数据失效 */@ThreadSafepublic 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变量：之前转载过一篇相关文章(), 当变量声明为volatile后，那么编译器或运行时会主要这个变量是共享的，不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或其他处理器不可见的地方，因此读取volatile变量总会返回最新的值。

比较典型的用法：

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

加锁机制既可以确保可见性又可以确保原子性，而volatile变量只可确保可见性，所以说volatile是一种轻量级同步机制；

满足以下所有条件时，可用volatile:

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

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

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

发布与逸出：

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

//对共有静态变量的发布，集合内部的变量也会被发布public static Set

//通过共有方法发布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
    
      connectionHolder = 	new ThreadLocal
     
      (){		@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类型发布不可变对象 */@ThreadSafepublic 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("");		}	}}