java并发编程(二): 对象的共享

原创
2014/03/23 16:27
阅读数 1.2K

对象的共享:

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

可见性:     

/**
 * 可见性问题导致,程序运行结果不正确
 * 有可能由于编译器,处理器及运行时做一些重排序
 */
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.保护对象。被保护对象只能通过持有特定锁来访问。保护对象包括封装在其他线程安全对象中的对象,以及已发布的并且由某个特定锁保护的对象。

不吝指正。

展开阅读全文
打赏
0
60 收藏
分享
加载中
有想过利用业余上网时间开个淘宝小店吗,门槛很低,而且不需要进货,所有货源都是厂家直接发货 ,在自己的网店上卖一件发货一件,能上网就可以!有兴趣加QQ:1328689347
2014/03/27 11:13
回复
举报
更多评论
打赏
1 评论
60 收藏
0
分享
在线直播报名
返回顶部
顶部