Java 并发编程之对象的共享

可见性

看下面这段代码

public class Init {
	public static boolean ready = false;
	public static int number = 0;

	public static class Readerthread extends Thread {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (!ready)
				Thread.yield();
			System.out.println(number);
		}

	}

	public static void main(String[] args) {
		new Readerthread().start();
		number = 42;
		ready = true;

	}
}

按照推论来讲，程序应该会输出42这个数字，Thread.yield();是将线程打回就绪状态，等待系统的下一次调度。实际上可能不是，程序可能输出0，或者 永远循环下去。读线程可能看到了ready的值，但却没有看到写入后number的值 。这种现象被叫做“重排序”，也就是说实际的执行顺序可能是先写入ready后写入Number。我也运行了几十次这个程序，倒是都会输出42.可能出错的机率比较小吧。解决这个问题的方法就是添加足够的同步。

几天之后我在项目中碰到了比这更好的例子

public class Init {
	public static boolean ready = false;
	public static int number = 0;

	public static class Readerthread extends Thread {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			number = 42;
			ready = true;
		}

	}

	public static void main(String[] args) {
		while (!ready)
			Thread.yield();
		System.out.println(number);
		new Readerthread().start();

	}
}

这个循环会100%的死循环下去。如何使此对象共享于两个线程之间呢

我想到了volatile关键字，用于确保可见性

public class Init {
	public volatile boolean ready = false;
	public volatile int number = 0;

	public class Readerthread extends Thread {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			number = 42;
			ready = true;
		}
	}
	public void test() {
		while (!this.ready) {
			Thread.yield();
			System.out.println(this.number);
		}
		System.out.println(this.number);
		new Readerthread().start();
	}

	public static void main(String[] args) {
		Init init = new Init();
		init.test();
	}
}

结果却很出乎意料。程序依旧死循环，再仔细一看就明白了。。原来这和并发编程没什么 关系。只是单纯的卡住了

如何解决。。很简单

public class Init {
	public volatile boolean ready = false;
	public volatile int number = 0;

	public class Readerthread extends Thread {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			number = 42;
			ready = true;
			System.out.println(ready);
		}
	}

	public void test() {
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (!ready) {
					Thread.yield();
					System.out.println(number);
				}
			}
		}).start();
		
		System.out.println(this.number);
		new Readerthread().start();
	}

	public static void main(String[] args) {
		Init init = new Init();
		init.test();
	}
}

失效数据

public class Init {

	private int vlaue;

	/**
	 * @return the vlaue
	 */
	public int getVlaue() {
		return vlaue;
	}

	/**
	 * @param vlaue
	 *            the vlaue to set
	 */
	public void setVlaue(int vlaue) {
		this.vlaue = vlaue;
	}
}

上面是一个非线程安全的整数类，第一眼看完可能都会认为应该对set方法进行同步 ，其实 不然。因为可能两个线程一个在调用set，另一个再用get.那么用get的那个线程可能看到更新后的value的值 ，也可能看不到。所以如果仅对set方法进行同步是不对的，也应该对get方法进行同步

public class Init {

	private int vlaue;

	/**
	 * @return the vlaue
	 */
	public synchronized int getVlaue() {
		return vlaue;
	}

	/**
	 * @param vlaue
	 *            the vlaue to set
	 */
	public synchronized void setVlaue(int vlaue) {
		this.vlaue = vlaue;
	}
}

非原子的64位操作

读到一个失效值 也比读到一个随机值好吧。这也是一种安全性保证 ，不过被称为最低安全性。

存在一个例外。java的内存模型要求，变量的读取和写入操作都必须是原子操作，但对于非volatile类型的Long和double变量 ，jvm允许将64位的读写 操作分解为两个32位的操作。只读一半的话,,,结果可想而知。解决办法则是用volatile关键字声明它们，或者加锁保护起来。

加锁与可见性

加锁的含义不仅仅局限于互斥行为，还包括内存可见性，为确保所有线程都能看到共享变量的最新值，那么所有执行读或写操作的线程都必须在同一个锁上进行同步 。换句话说就是在加锁和解锁之间的代码块里的内容都是线程可见的。

Volatile变量

这是java提供的一种稍弱的同步机制，用于确保变量的更新通知到其它线程。它只确保可见性而不可确保原子性。用于循环中的中止变量等地方比较合适，等其它一些不需要准确的数值的地方。以下三种情况才应该使用

• 对变量的写入操作不依赖变量的当前值，（如Count++就不行）或者能确保是在单线程中更新变量值
• 该变量不会与其他状态变量 一起纳入不变性条件中。（这个的意思 是不会影响到其它变量为前提吧？）
• 在访问变量时不需要加锁

发布与逸出

发布一个对象 的意思 是指，使对象能够在当前作用域之外的代码中使用，例如，将一个指向该对象的引用保存到其他代码可以访问的地方。许多情况下我们要确保对象的内部状态不被 发布。如果发布了那么就会破坏线程安全性。当不该发布的对象被发布时这种情况被 叫做逸出。如下面这种情况。

public class unsafe {

	private String[] state = new String[] { "sdf", "fdsf" };

	public String[] getstate() {
		return state;
	}
}

常见的还有隐式的this逸出

如

button.setonclicklistener(new onclicklistener(){

		public void onEvent(Event e){

		dosomething(e);

		}

	});

参考资料：《java并发编程实战》