JCIP chap3 share objects

“同步”确保了操作的原子性执行，但它还有其它重要的方面：memory visibility.我们不但要确保当一个线程在使用一个对象的时候，其它线程不能修改这个对象，而且还要保证该线程在修改对象状态时，其它线程能够看到该线程对对象所做的改变。

可以通过显式的同步语句或内建类库的同步机制以保证对象的正确发布。

3.1. Visibility

3.1.1. Stale Data

3.1.2. Non-atomic 64-bit Operations(针对没有声明为volatile的double和long)

Java内存模型要求读取和写入操作都是原子性的，但对于非volitile的long和double变量，jvm通过两个32位操作来完成一个64位的读写。

因此，当在一个多线程程序中有double和long型的共享变量是，对它的读写一定要加volatile或通过锁来同步

3.1.3. Locking and Visibility

3.1.4. Volatile Variables

锁能确保可见性和原子性，volitale只能保证可见性

3.2. Publication and Escape

发布一个对象是指该对象在它当前的上下文范围之外是可用的，如存储一个引用，使其他代码能够访问、通过非私有的方法返回自己、或者是将自己传递给另一个类的方法中（特别注意！！）。

//Publishing an Object
//发布一个对象，通过静态字段引用它
public static Set<Secret> knownSecrets;

public void initialize(){
	knownSecrets = new HashSet<Secret>();
}

//Allowing Internal Mutable State to Escape.Don't do this.
//私有变量通过公共方法逃逸

class UnsafeStates{
	private String[] states = new String[]{"ak","al",...};

	public String[] getStates(){
		return states;
	}
}

发布一个对象，有可能同时会发布它字段锁引用的对象，这些对象通过它的公有变量或共有的get方法发布出来，要小心无意的泄漏。

小心，不要在你的构造方法里面泄漏了你的对象!!!

public class ThisEscape{
	public ThisEscape(EventSource source){
		source.registerListener(new EventListener{
			public void onEvent(Event e){
				doSomething(e);
			}
		});
	}
}

3.2.1. Safe Construction Practices

从构造函数中发布一个对象（匿名内部类实现），会导致当前对象也跟着发布，但是当前对象的构造函数还没有返回，即它不一定被正确的构建就已经发布了

Do not allow the this reference to escape during construction.

一个常见错误是在构造函数中起一个线程，这样会提前发布this引用。

//ThisEscape 改进版本
public class SafeListener{
	private final EventListener listener;

	private SafeListener(){
		listener = new EventListener(){
			public void onEvent(Event e){
				doSomething(e);
			}
		};
	}

	public static SafeListener newInstance(EventSource source){
		SafeListener safe = new SafeListener();
		source.registerListener(safe.listener);
		return safe;
	}
}

3.3. Thread Confinement

3.3.1. Ad-hoc Thread Confinement

3.3.2. Stack Confinement

就是本地变量

//本地原是类型和引用类型的线程封闭
public int loadTheArk(Collection<Animal> candidates){
	SortedSet<Animals> animals;
	int numPairs = 0;
	Animal candidate = null;
	animals = new TreeSet<Animal>(new SpeciesGenderComparator());
	animals.addAll(candidates);
	for(Animal a:animals){
		if(candidate == null || !candidate.isPotentialMate(a))
			candidate = a;
		esle{
			ark.load(new AnimalPair(candidate,a));
			++ numPairs;
			candidates = null;
		}
	}
	return numPairs;
}

3.3.3. ThreadLocal

//using ThreadLocal to ensure thread confinement
private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>(){
	public Connection initialValue(){
		return DriverManager.getConnection(dburl);
	}
};

public static Connection getConnection(){
	return connectionHolder.get();
}

该技术适用于频繁申请临时对象的操作，即每来一个线程，就分配一个临时对象的情况。但是不要滥用，会增加耦合性。

3.4. Immutability

不可变对象总是线程安全的。

//一个不可变对象
@Immutable
public final class /threeStooges{
	private fianl Set<String> stooges = new HashSet<String>();

	public ThreeStooges(){
		stooges.add("Moe");
		atooges.add("Larry");
		stooges.add("Curly");
	}
	public boolean isStooge(String name){
		return stooges.contain(name);
	}
}

3.4.1 Final Fields

就像对象的字段如果不需要保持对外可见，用private修饰一样，若字段不需要修改，那么也要设置为final

3.4.2 Example: Using Volatile to Publish Immutable Objects

3.5. Safe Publication

3.5.1 Improper Publication:When Good Objects Go Bad

3.5.2 Immutable Objects and initialization Safety

3.5.3 Safe Publication Idioms

要安全发布一个对象，对该对象的引用与对象的状态必须同时对其他线程可见。一个正确构建的对象可以通过如下步骤被安全发布：

• 使用静态初始化器初始化一个对象引用
• 将引用存储为volatile或AtomicReference
• 将引用存为一个正确构建的对象的final字段
• 将引用存为一个字段，该字段用适当的锁来保护

推荐使用静态初始化器，如：

public static Holder holder = new Holder(12);

这样发布的对象一定是安全的。

3.5.4 Efectively immutable Objects

事实不可变对象（对象在发布后就不需要改变，但是技术上是可变的），在发布之后不会被修改的对象，那么只要保证安全发布就好了，由于后续不需修改，也就不用同步机制来保证可见性。例如，Date就是可变对象，但是假如你不去修改它，那么就不需要锁来保证可见性。

3.5.5 Mutable Objects

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

• 不可变对象可以通过任何机制发布
• 事实不可变对象必须安全发布
• 可变对象必须安全发布，而且必须线程安全或通过锁来保护

3.5.6 Sharing Objects Safely

当你发布一个对象，你要指定该对象应该被怎样访问

在并发程序中，使用和共享对象的最有效的策略是：

• 线程封闭：该对象为该线程独有，其他线程无法修改
• 只读共享：其它线程无法修改该对象，也就不会有线程问题，可以用不可变对象或事实不可变对象
• 线程安全共享：一个线程安全的对象使用内部同步，那么多线程可以自由的获取或修改它而不需要额外的同步机制
• 监视状态：一个受监视的对象只能通过持有正确锁的线程来访问。