Effective Java学习(并发)之——同步访问共享可变数据

       关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法，或者某一个代码快。许多程序员把同步的概念仅仅理解为一种互斥的方式，即，当一个对象被一个线程修改的时候，可以阻止另一个线程观察到对象内部不一致的状态。按照这种观点，对象被创建的时候处于一致状态，当有方法访问他的时候，它就被锁定了。这些方法观察到对象的状态，并且可能会引起状态转变，即把对象从一种一致状态转换到另一种一致状态。正确的使用同步可以保证没有任何方法会看打对象处于不一致的状态中。

 

        这种观点是正确的，但是他没有说明同步的全部意义，如果没有同步，一个线程的变化就不能被其他线程看到。同步不仅可以阻止一个线程看到对象处于不一致的状态之中，它还可以保证进入同步方法或者同步代码块的每个线程，都看到有同一个锁保护的之前所有的修改效果。

 

     Java语言规范保证读或者写一个变量是原子的，除非这个变量的类型为long或者double。换句话说，读取一个非long或者double类型变量，可以保证返回的值是某个线程保存在改变两中的，即使多个线程在没有同步的情况下并发的修改这个变量也是如此。

 

       你可能听说过，为了提高性能，在读写原子数据的时候，应该避免使用同步。这个建议是非常危险而错误的。虽然语言规范保证了线程在读取原子数据的时候，不会看到任意的数值，但是并不保证一个线程写入的值对于另一个线程将是可见的。为了在线程之间进行可靠的通信，也为了互斥访问，同步是必要的， 这归于Java语言规范中的内存模型，他规定了一个线程所做的变化何时以及如何变成对其他线程可见。

 

      如果对共享的可变数据的访问不能同步，其后果将非常可怕，即使这个变量是原子可读写的。考虑下面这个阻止一个线程妨碍另一个线程的任务。Java的类库中提供了Thread.stop方法，但是这个方法在很久就不提倡使用，因为本质是不安全的——使用他会导致数据遭到破坏。不要使用Thread.stop。要阻止一个线程妨碍另一个线程，建议的做法是让第一个线程轮询一个boolean域，这个域一开始为false，但是可以通过第二个线程设置为true，以表示第一个线程将终止自己。由于boolean域的读写操作都是原子的，程序员在访问这个域的时候不再使用同步。

 

package com.sg.effective.study.four;

import java.util.concurrent.TimeUnit;

public class StopThread {
	private static boolean stopRequested;
	
	public static void main(String[] args) throws InterruptedException {
		Thread backgroundThread = new Thread(new Runnable() {
			
			@Override
			public void run() {
				int i = 0;
				while(!stopRequested){
					i++;
				}
			}
		});
		backgroundThread.start();
		TimeUnit.SECONDS.sleep(1);
		stopRequested = true;
	}
}

       你可能期待这个程序运行大约一秒钟左右，之后主线程将stopRequested设置为true，致使后台线程的循环终止，。但是根据不同运行机器的运行环境，这个程序永远不会终止：因为后台线程永远在循环。

 

 

       问题在于，由于没有同步，就不能保证后台线程何时‘看到“主线程对stopRequested的值所做的改变。没有同步，虚拟机将这个代码

 

while(true){
      i++;
}

 转变成这样：

 

 

if(!done){
      while(true){
             i++;
       }
}

       这是可以接受的，这种优化称作提升，正是HopSpot Server VM的工作、结果是个活性失败：这个程序无法前进。修正这个问题的一种方式是同步访问stopRequested域，这个程序会如期般在大约一秒钟之内终止：

 

 

package com.sg.effective.study.four;

import java.util.concurrent.TimeUnit;

public class StopThread {
	private static boolean stopRequested;
	
	private static synchronized void requestStop(){
		stopRequested = true;
	}
	
	private static synchronized boolean stopRequested(){
		return stopRequested;
	}
	
	
	public static void main(String[] args) throws InterruptedException {
		Thread backgroundThread = new Thread(new Runnable() {
			
			@Override
			public void run() {
				int i = 0;
				while(!stopRequested()){
					i++;
				}
			}
		});
		backgroundThread.start();
		TimeUnit.SECONDS.sleep(1);
		requestStop();
	}
}

       注意写方法和读方法都被同步了。只同步写方法还不够，实际上，如果读和写操作没有都被同步，同步就不会起作用。

 

 

    StopThread中被同步的方法动作即使没有同步也是原子的，换句话说，这些方法的同步只是为了他的通信效果，而不是为了互斥访问。虽然循环的每个迭代中的同步开销很小，还是有其他更正确的替代方法，他更加简便，性能也可能更好。如果stopRequested被声明为volatile，第二种版本的StopThread中的锁就可以省略。虽然volatile修饰符不执行互斥访问，但他可以保证任何一个线程在读取该域的时候都将看到最近刚刚被写入的值：

 

package com.sg.effective.study.four;

import java.util.concurrent.TimeUnit;

public class StopThread {
	private static volatile boolean stopRequested;
	
	public static void main(String[] args) throws InterruptedException {
		Thread backgroundThread = new Thread(new Runnable() {
			
			@Override
			public void run() {
				int i = 0;
				while(!stopRequested){
					i++;
				}
			}
		});
		backgroundThread.start();
		TimeUnit.SECONDS.sleep(1);
		stopRequested = true;
	}
}

      在使用volatile的时候务必要小心。考虑下面的方法，假设他要产生序列号：

 

 

private static volatile int nextSerialNumber = 0;
	
	public static int generateSerialNumber(){
		return nextSerialNumber++;
}
	

       这个方法的目的是要确保每个调用都返回不同的值。这个方法的状态只包含一个可原子访问的域：nextSerialNumber，这个域的所有的值都是合法的，因此，不需要任何同步来保护他的约束条。然而，如果没有同步，这个方法仍然无法正常运行。

 

 

       问题在于，增量操作符（++）不是原子的。他在nextSerialNumber域中执行两项操作：首先他读取值，然后写回一个新值，相当于原来的值上加1.如果第二个线程在第一个线程读取旧值和写回新值期间读取了这个域，第二个线程就会与第一个线程一起看到同一个值，并返回相同的序列号，这就是安全性失败：这个程序会计算出错误的结果。

 

   修正generateSerialNumber方法的一种是在他生命中增加synchronized修饰符。这样可以确保多个调用不会交叉存取。确保每个调用都会看到之前所有的效果，一旦这么做，就可以且应该从nextSerialNumber中删除volatile修饰符。为了让这个方法更可靠，要使用long代替int，或者在nextSerialNumber快要重叠的时候抛出异常。

 

    最好还是使用AtomicLong，他是java.util.concurrent.atomic的一部分。他所做的工作正是你想要的，并且有可能不同步版的generateSerialNumber执行得更好：

 

private static final AtomicLong nextSerialNumber = new AtomicLong();
	
	public static long generateSerialNumber(){
		return nextSerialNumber.getAndIncrement();
}

       避免以上所说的问题的最佳的办法是不共享可变数据，要么共享不可变的数据，要么压根不共享。换句话说，将可变数据限制在某个单个线程中。如果采用这一策略，对他建立文档就很重要，以便他可以随着程序的发展得到维护，深刻的理解正在使用的框架和类库也很重要，因为他们引入了你所不知道的线程。

 

 

    让一个线程在短时间内修改一个数据对象，然后与其他线程共享，这是可以接受的，只同步共享对象引用的动作，然后其他线程没有进一步的同步也可以读取对象，只要他没有再被修改。这种对象被称作事实上不可变的。将这种对象引用从一个线程传递到其他线程被称作安全发布。安全发布对象有很多种方法：可以将它保存在volatile域、final域或者通过正常锁定访问的域中；或者可以将它放到并发的集合中。

 

    简而言之，当多个线程共享可变数据的时候，每个读或者写数据的线程都必须执行同步 如果没有同步，就无法保证一个线程所做的修改可以被另一个线程获知。未能同步共享可变数据会造成程序的活性失败和安全性失败。这样的失败是难以调式的。他们可能是间歇性的，且与时间相关，程序的行为在不同的VM上可能根本不同，如果只需要线程之间的交互通信，而不需要互斥，volatile修饰符就是一种可以接受的同步形式，但是正确的使用它可能需要一些技巧。