对象的共享：
要编写并发程序，关键在于：在访问共享的可变状态时需要进行正确的管理
可见性：
/**
* 可见性问题导致，程序运行结果不正确
* 有可能由于编译器，处理器及运行时做一些重排序
*/
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 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想成Map, 当线程终止时 ，这些值会作为垃圾回收。比如，多线程环境下，我们可以这样获取数据库连接：
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类型发布不可变对象
*/
@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.保护对象。被保护对象只能通过持有特定锁来访问。保护对象包括封装在其他线程安全对象中的对象，以及已发布的并且由某个特定锁保护的对象。
不吝指正。
558
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
