多线程中共享对象的可见性

在阅读《java并发编程实战》的第三章的时候，看到书中的一个例子，随在Eclipse中执行看看效果。示例代码如下：

 

public class NoVisibility {
	private static boolean ready;
	private static int number;
	
	private static class ReaderThread extends Thread {
		public void run() {
			while(!ready) {
				Thread.yield();
			}
			
			System.out.println(number);
		}
	}
	
	public static void main(String[] args) {
		new ReaderThread().start();
		
		number = 42;
		ready = true;
	}
}

 

 

书中的解释是，这个程序的执行结果除了打印出42以外，还有两外另种情况：一时无限循环下去，二是打印出0来。其中打印42很好理解，因为，在启动ReaderThread线程以后，如果还没有设置ready为true，那么ReaderThread会一直循环，直到读取ready的值为true，然后打印出结果42来。

 

无限循环这个结果，通过代码来测试是很难观察到的，但是通过书中的分析，这种情况是存在的。这个示例中的number和ready，会被两个线程访问，其一是运行该程序的main线程，其二是ReaderThread线程，所以这两个变量可以称之为共享变量，由于java虚拟机自己的缓存机制，在缺少同步的情况下，会将number和ready的数值缓存在寄存器中，这就会导致ReaderThread线程在某些情况下读取不到最新的值，这样即使在main方法中将ready设置为true了，但是ReaderThread线程读取的ready值仍然为false，这样就会导致一直循环下去。

 

上面的这个示例很难观察到这种情况，所以我对其进行了改造，可以看到另外一种与我们预期不相符的情况：

 

public class NoVisibility {
	private static boolean ready;
	private static int number;
	
	private static class ReaderThread extends Thread {
		public void run() {
			while(!ready) {
				System.out.println(System.currentTimeMillis());
				Thread.yield();
			}
			
			System.out.println(number);
		}
	}
	
	public static void main(String[] args) {
		for(int i=0;i < 100;i++)
			new ReaderThread().start();
		
		number = 42;
		ready = true;
	}
}

  对示例代码做了两处改动，第一，在ReaderThread线程的while循环中打印当前时间，第二，在main方法中增加了一个循环，创建了100个ReaderThread线程并启动线程。然后我们看看运行结果：（这里只列出了部分结果）

 

 

...
1354960834108
42
1354960834108
1354960834108
42
1354960834108
42
1354960834108
1354960834108
1354960834108
1354960834108
42
42
...

 

 

从打印的结果来看，就会发现问题，为什么在某些线程打印了42以后，有些线程仍然在打印时间?

如果某个线程打印出了42，说明main方法已经执行完毕，即变量ready的值已经设置为true了，那么这以后其它的线程打印的结果应该都是42了，但这里的结果是有些线程读取的ready值仍然为false，这就说明了java虚拟机会对线程中使用到的变量进行缓存，所以就出问题了。

java虚拟机缓存变量，是出于性能的考虑，并且在单线程程序中，或者不存在共享变量的多线程程序中，这都不会出现问题。但是，在有共享变量的多线程程序中，就会发生问题，这里就涉及到共享对象的可见性了，也就是在没有使用同步机制的情况下，一个线程对某个共享对象的修改，并不会立即被其它的线程读取到。上面的代码之所以会出问题，就是因为ReaderThread线程，没有读取到main线程对ready变量修改后的值。要解决上述问题，可以通过在main方法和ReaderThread线程中的run方法中，给访问number和ready值的代码块中加锁来解决。

 

另外一种结果打印出0来，这个暂时还不是很明白，书中的解释是java虚拟机的内存模型允许编译器对操作顺序进行重排序，并将数值缓存在寄存器中，这样可能在读取到ready修改后的值后，却仍然读取了number的旧值，从而打印出了int的默认值0来。

 

 

 

 

评论

6 楼 60love5 2016-12-14  

60love5 写道

首先谢谢你的解析，但你这个验证可见性的小程序是存在问题的，你的那个输出说明不了任何问题。在这里，有一个事实就是，先打印出来的不一定就是先执行完的。如果你在打印 42 的同时，也打印当前时间，你就会发现：即使在打印 42 之后会打印出时间，那这个时间的生成时间也要早于 打印42的时间。下面这个程序说明了这一点：

public class NoVisibility {
	private static boolean ready;
	private static int number;
	private static final AtomicLong count = new AtomicLong(0);

	private static class ReaderThread extends Thread {
		public ReaderThread(String name) {
			super(name);
		}

		public void run() {
			while (!ready) {
				System.out.println(Thread.currentThread().getName() + " : "
						+ count.incrementAndGet() + " # "
						+ System.currentTimeMillis());
				Thread.yield();
			}
			System.out.println(Thread.currentThread().getName() + " : "
					+ count.incrementAndGet() + " # " + number + " # "
					+ System.currentTimeMillis());
		}
	}

	public static void main(String[] args) {
		Thread.currentThread().setPriority(10);
		for (int i = 0; i < 1000; i++) {
			Thread thread = new ReaderThread("Thread-" + i);
			thread.start();
		}

		number = 42;
		ready = true;

		System.out.println("--- main-Thread Over : "
				+ System.currentTimeMillis() + " ---");
	}
}/* Output: (输出片段，结果不唯一：)
        Thread-482 : 794 # 1481685379575
        Thread-485 : 2604 # 42 # 1481685379625
        Thread-482 : 2605 # 42 # 1481685379625
        Thread-487 : 793 # 1481685379575
        Thread-486 : 792 # 1481685379575
        Thread-480 : 791 # 1481685379575
        Thread-483 : 790 # 1481685379575
 *///:~

5 楼 60love5 2016-12-14  

首先谢谢你的解析，但你这个验证可见性的小程序是存在问题的，你的那个输出说明不了任何问题。在这里，有一个事实就是，先打印出来的不一定就是先执行完的。如果你在打印 42 的同时，也打印当前时间，你就会发现：即使在打印 42 之后会打印出时间，那这个时间的生成时间也要早于 打印42的时间。下面这个程序说明了这一点：

public class NoVisibility {
	private static boolean ready;
	private static int number;
	private static final AtomicLong count = new AtomicLong(0);

	private static class ReaderThread extends Thread {
		public ReaderThread(String name) {
			super(name);
		}

		public void run() {
			while (!ready) {
				System.out.println(Thread.currentThread().getName() + " : "
						+ count.incrementAndGet() + " # "
						+ System.currentTimeMillis());
				Thread.yield();
			}
			System.out.println(Thread.currentThread().getName() + " : "
					+ count.incrementAndGet() + " # " + number + " # "
					+ System.currentTimeMillis());
		}
	}

	public static void main(String[] args) {
		Thread.currentThread().setPriority(10);
		for (int i = 0; i < 1000; i++) {
			Thread thread = new ReaderThread("Thread-" + i);
			thread.start();
		}

		number = 42;
		ready = true;

		System.out.println("--- main-Thread Over : "
				+ System.currentTimeMillis() + " ---");
	}
}

4 楼 beyondfengyu 2016-04-19  

从打印的结果来看，就会发现问题，为什么在某些线程打印了42以后，有些线程仍然在打印时间?
这样也不能说明是JVM做了缓存才出现的问题，因为代码中跑了100条线程，有可能出现一种情况是，很多线程在执行System.out.println(System.currentTimeMillis());  时，刚好某个线程A打印了42，这时代表主线程执行完毕，此时ready=true，然后其它线程再执行while(!ready)时判断为false，执行打印语句。

我对你原来的做了修改
private static boolean ready;
private static int number;
private static AtomicInteger ss = new AtomicInteger();
private static class ReaderThread extends Thread {
public void run() {
while(!ready) {
System.out.println(System.currentTimeMillis());
Thread.yield();
}

System.out.println(ss.incrementAndGet()+"_"+number);
}
}

public static void main(String[] args) {
for(int i=0;i < 100;i++)
new ReaderThread().start();

number = 42;
ready = true;
}

加了一个ss变量显示打印的次数，刚好打印的是100次，如果按你的分析，它打印的次数有可能不是100次

3 楼 kililanxilu 2013-09-23  

aswang 写道

Scooler 写道

打印出0，现在的jdk没这个问题了。。

早期的jdk如1.2，1.3 允许无序写入。。
代码和实际执行顺序不一致，如下列代码，

number = 42; 
ready = true;

----------------------------------------
可能执行的顺序是：

ready = true;
number = 42; 

这样number还没初始化，就打印出0了

是的，早期的jdk中存在，新的版本貌似解决了，但是没找到明确解释。

貌似没有看到JDK有这方面的改动。重排序有个as-if-serial语义原则。就是如果交换顺序不会对下方的的语句产生影响就可以执行重排序，遵循了这种原则的情况下感觉任然是按照顺序执行。应该还是可能出现0这种情况的。我也是刚好看到这块，大家讨论下。http://www.infoq.com/cn/articles/java-memory-model-2

2 楼 aswang 2012-12-10  

Scooler 写道

打印出0，现在的jdk没这个问题了。。

早期的jdk如1.2，1.3 允许无序写入。。
代码和实际执行顺序不一致，如下列代码，

number = 42; 
ready = true;

----------------------------------------
可能执行的顺序是：

ready = true;
number = 42; 

这样number还没初始化，就打印出0了

是的，早期的jdk中存在，新的版本貌似解决了，但是没找到明确解释。

1 楼 Scooler 2012-12-10  

打印出0，现在的jdk没这个问题了。。

早期的jdk如1.2，1.3 允许无序写入。。
代码和实际执行顺序不一致，如下列代码，

number = 42; 
ready = true;

----------------------------------------
可能执行的顺序是：

ready = true;
number = 42; 

这样number还没初始化，就打印出0了