专栏首页做不甩锅的后端多线程基础(四):volatile和可见性问题及happens-before原则

多线程基础(四):volatile和可见性问题及happens-before原则

在前文中知道了synchronized的使用,以及java内存模型JMM的基本构成。那么现在,我们来看一个新的问题。

1.可见性问题

我们来看看下面这段代码:

package com.dhb.concurrent.test;

import java.util.concurrent.TimeUnit;

public class VolatileTest {

	private static int INIT = 0;
	private static int MAX = 10;

	public static void main(String[] args) {

		new Thread(() -> {
			int local = INIT;
			while (local < MAX) {
				if (local != INIT) {
					System.out.println("Get change for INIT [" + INIT + "] local is [" + local + "]");
					local = INIT;
				}
			}
		}, "Reader Thread").start();

		new Thread(() -> {
			int local = INIT;
			while (local < MAX) {
				System.out.println("Update value [" + local + "] to [" + (local++) + "]");
				INIT = local;
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "Writer Thread").start();
	}

}

有两个线程,一个线程写入,另外一个线程读取,那么写入线程的结果,每次都能被读取线程读到吗?我们执行上述代码:

Update value [0] to [0]
Get change for INIT [1] local is [0]
Update value [1] to [1]
Update value [2] to [2]
Update value [3] to [3]
Update value [4] to [4]
Update value [5] to [5]
Update value [6] to [6]
Update value [7] to [7]
Update value [8] to [8]
Update value [9] to [9]

可以看到,在写入线程将INIT结果递增的过程中,读取线程只读到了第一次的值。之后无论写入线程对INIT的值如何改变,在读取线程中,这个值任然是之前的结果,也就是写入线程增加的值,对读取线程实际上是不可见的。这就是我们今天需要介绍的重点,可见性问题。

如上图,每个线程实际上都是在自身的工作内存中操作的变量的副本,如果这个副本被修改之后,则会同步回主内存。因此Writer每次都将结果写入到主内存的INIT中去。但是对于Reader线程,只会在读取之后进行比较的时候读取一次,此时的值为1,那么在此之后,这个值就不会被修改了,而是一直将这个值放在该线程的工作内存中。这就是可见性问题产生的原因。实际上就是,由于Reader线程只是读取,内部只有use操作,因此不会assign,那么也就没有必要每次都从主内存中去加载这个变量。这样设计的初衷是为了增加JVM内存计算的效率,因为工作内存可能实际的部分在CPU的高速缓存中进行计算,如果每次都从主内存中加载,由于高速缓存和主内存的速度相差很大,那么就会导致不必要的系统开销。 那么我们应该怎么解决这个问题呢。这就是本文需要介绍的重点关键字,volatile。这个关键字有两个作用:

  • 保持内存可见性
  • 静止指令重排序 我们先来说内存的可见性。volatile是如何保持内存的可见性呢?很简单,实际上如果某个变量被volatile修饰的话,那么在工作内存中,就不再走工作内存的缓存了,而是每次都去主内存去加载。这样一来,虽然带来了一些性能的损耗,但是这样可以更好的解决系统的一致性。

如上图,这样一来,Reader线程的工作内存中在对INIT的读取的时候,每次都会从主内存中去同步。这样Writer线程对主内存的修改,对Reader线程来说,就是可见的了。我们修改代码如下:

public class VolatileTest {

	private volatile static int INIT = 0;
	private static int MAX = 10;

	public static void main(String[] args) {

		new Thread(() -> {
			int local = INIT;
			while (local < MAX) {
				if (local != INIT) {
					System.out.println("Get change for INIT [" + INIT + "] local is [" + local + "]");
					local = INIT;
				}
			}
		}, "Reader Thread").start();

		new Thread(() -> {
			int local = INIT;
			while (local < MAX) {
				System.out.println("Update value [" + local + "] to [" + (local++) + "]");
				INIT = local;
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "Writer Thread").start();
	}

}

执行结果:

Update value [0] to [0]
Get change for INIT [1] local is [0]
Update value [1] to [1]
Get change for INIT [2] local is [1]
Update value [2] to [2]
Get change for INIT [3] local is [2]
Update value [3] to [3]
Get change for INIT [4] local is [3]
Update value [4] to [4]
Get change for INIT [5] local is [4]
Update value [5] to [5]
Get change for INIT [6] local is [5]
Update value [6] to [6]
Get change for INIT [7] local is [6]
Update value [7] to [7]
Get change for INIT [8] local is [7]
Update value [8] to [8]
Get change for INIT [9] local is [8]
Update value [9] to [9]
Get change for INIT [10] local is [9]

这样reader线程每次都能读到最新的INIT的值了。

2.指令重排序

我们来看下面这个例子:

package com.dhb.concurrent.test;

public class VolatileTest2 {

	static int a,b,x,y;

	public static void main(String[] args) {
		long time = 0;
		while (true) {
			time ++;
			a = 0;
			b = 0;
			x = 0;
			y = 0;
			Thread t1 = new Thread(() -> {
				a = 1;
				x = b;
			});
			Thread t2 = new Thread(() -> {
				b = 1;
				y = a;
			});
			t1.start();
			t2.start();
			try {
				t1.join();
				t2.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			if( x==0 && y==0) {
				break;
			}
		}
		System.out.println("time:["+time+"] x:["+x+"] y:["+y+"]");
	}
}

对于指令重排序,如果在一个线程中,两条语句之间彼此没有任何关系,那么在jvm内部对指令进行优化的时候,就可以出现,写在后面的语句被优化到前面执行的情况。在这个例子中, a=1、x=b 这是两条没有任何关系的语句,同样,在另外一个线程中b=1、y=a也如此。这些语句彼此间没有先后关系。而在传统的逻辑中,这两种组合,无论哪个线程先执行或者同时执行,都不会出现x=0,y=0的情况。

执行情况

结果

t1先于t2执行

x=0,y=1

t2先于t1执行

x=1,y=0

t1、t2同时执行

x=1,y=1

只有当出现指令重排序,x=a,y=b先于a=1,b=1执行,那么才可能出现x=0,y=0的情况。 我们执行上述代码:

time:[102946] x:[0] y:[0]

这个指令重排序不是一个必然事件,因此这个代码每次执行的结果都不一样:

time:[8943] x:[0] y:[0]

如果运气好可能很快就会出现这个结果。 这就是指令重排序问题。那么volatile的另外一个作用就是能够禁止指令重排序,这种情况就不会产生。这也是一个比较常见的面试问题,DCL的单例模式需要加volatile的的原因。

3.synchronized与可见性

在JMM中,关于synchronized有两条规定:

  • 线程解锁之前,必须把共享变量的最新值刷新到主内存中。
  • 线程加锁的时候,将清空工作内存中的共享变量的值,从而使共享变量需要从主内存中重新获取最新的值。(加锁与解锁是同一个锁)

由此可见,synchronized,实际上也能实现可见性。此外,synchronized使用的是同步锁,还具有原子性。 再回到前文的例子中,我们将这个程序改造为如下方式:

package com.dhb.concurrent.test;

import java.util.concurrent.TimeUnit;

public class SyncTest {

	private static Count count = new Count();
	private static int MAX = 10;

	public static void main(String[] args) {

		new Thread(() -> {
			int local = count.getCount();
			while (local < MAX) {
				synchronized (count) {
					if (local != count.getCount()) {
						System.out.println("Get change for INIT [" + count.getCount() + "] local is [" + local + "]");
						local = count.getCount();
					}
				}
			}
		}, "Reader Thread").start();

		new Thread(() -> {

			int local = count.getCount();
			while (local < MAX) {
				synchronized (count) {
					System.out.println("Update value [" + local + "] to [" + (++local) + "]");
					count.setCount(local);
				}
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

		}, "Writer Thread").start();


	}

	private static class Count {
		int count = 0;

		public int add() {
			return ++count;
		}

		public int getCount() {
			return count;
		}

		public void setCount(int count) {
			this.count = count;
		}
	}

}

之后我们再来看执行结果:

Update value [0] to [1]
Get change for INIT [1] local is [0]
Update value [1] to [2]
Get change for INIT [2] local is [1]
Update value [2] to [3]
Get change for INIT [3] local is [2]
Update value [3] to [4]
Get change for INIT [4] local is [3]
Update value [4] to [5]
Get change for INIT [5] local is [4]
Update value [5] to [6]
Get change for INIT [6] local is [5]
Update value [6] to [7]
Get change for INIT [7] local is [6]
Update value [7] to [8]
Get change for INIT [8] local is [7]
Update value [8] to [9]
Get change for INIT [9] local is [8]
Update value [9] to [10]
Get change for INIT [10] local is [9]

这样通过synchronized也能很好的解决可见性问题。由于synchronized在1.8中已经做了很多优化,其性能与ReentrantLock的性能无差别,因此,只要不涉及到指令的重排序,通过synchronized也能很好的完成可见性的效果。

如上图所示,在加锁之后,每次读写的时候都需要从主内存中刷新同步。

4.Happens-Before规则

在《深入理解Java虚拟机》一书中,对Happens-Before原则进行了归纳,主要是以下8个:

  • 1.程序次序规则:在同一线程内部,按照代码顺序,关联代码书写在前面的操作优先发生于书写在后面的操作。
  • 2.管程锁定规则:一个unlock操作优先发生于此后对同一个锁的lock操作。
  • 3.volatile变量规则:对一个变量的写操作优先发生于后面对这个变量的读操作。(时间先后)
  • 4.线程启动规则:Thread的start方法优先发生于此线程的每一个动作。
  • 5.线程终结规则:线程中所有操作都优先发生于线程的终止检测,我们可以通过Thread.join()、Thread.isAlive()返回值等手段进行检测。
  • 6.线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到事件的发生。
  • 7.对象终结规则:一个对象的初始化完成先于发生他的finalize()方法的开始。
  • 8.传递性规则:如果操作A对操作B可见,而操作B又对操作C可见,则可以得出操作A对操作C也可见。 如何来理解这些Happens-Before规则呢?Happens-Before并不是说,前一个操作发生在后续操作的前面。而是要表达,前面一个操作的结果对后续操作是可见的。 实际上,Happens-Before对编译器的行为进行了约束,编译器可以根据需要多代码的执行顺序进行优化,但是,编译器的这种优化一定要遵守Happens-Before规则。

5.对Happens-Before的理解

5.1 程序次序规则

需要注意的是,对于这个规则,一jvm在优化的时候,如果书写的代码之间没有任何的依赖关系,那么就不符合这个规则了。 如下代码:

int a = 3;     //代码1
int b = a + 1; //代码2

由于存在依赖关系,因此代码1的结果对代码2永远都是可见的。

int a = 3; //代码1
int b = 2; //代码2

那么上面这个代码,就不会有次序关系了,JVM指令会根据需要进行优化。优化之后的顺序就不一定了。可能是先执行代码1,也可能是先执行代码2。

5.2 管程锁定规则

这个规则很好理解,也就是说,在需要对一个锁进行加锁的时候,其上面的unlock操作一定是先执行的。

5.3 volatile变量规则

如果变量被volatile修饰,那么对这个变量的写操作,一定会被其后的所有读操作可见。 这也是本文前面的例子所证明的这一点。

public class VolatileTest {

	private volatile static int INIT = 0;
	private static int MAX = 10;

	public static void main(String[] args) {

		new Thread(() -> {
			int local = INIT;
			while (local < MAX) {
				if (local != INIT) {
					System.out.println("Get change for INIT [" + INIT + "] local is [" + local + "]");
					local = INIT;
				}
			}
		}, "Reader Thread").start();

		new Thread(() -> {
			int local = INIT;
			while (local < MAX) {
				System.out.println("Update value [" + local + "] to [" + (local++) + "]");
				INIT = local;
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "Writer Thread").start();
	}

}

5.4 传递性规则

如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C。这有点类似于数学中的传递性规则。如果A>B,B>C,那么A>C。

package com.dhb.concurrent.test;

public class VolatileExample {

	static  int x = 0;
	static volatile boolean v = false;

	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			x = 42;
			v = true;
		});

		Thread t2 = new Thread(() -> {
			if(v == true){
				System.out.println(x);
			}else {
				System.out.println(x);
			}
		});

		t1.start();
		t2.start();
		try {
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

在上述例子中,如果t1一定会在前面执行的话,那么根据传递性规则,该结果输出一定是42。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • rabbitmq-3.7.7安装过程

    rabbtmq 依赖于erlang,rabbitmq 3.7.7 版本对erlang的依赖关系参见:http://www.rabbitmq.com/which-...

    冬天里的懒猫
  • java线程池(二):聊聊newFixedThreadPool(1)和newSingleThreadExecutor()的区别

    在第一部分中介绍完java中Executors的线程池创建的方式之后,实际上有一个非常好奇的问题。既然newFixedThreadPool(1)也能保证...

    冬天里的懒猫
  • 多线程基础(三):synchronized关键字及java内存模型简介

    在前面了解过一些java多线程基础之后,现在,我们用多线程来解决一个实际问题。 假定每个线程可以将一个数字加到100000,现在我们用十个线程,同时相加,看看...

    冬天里的懒猫
  • 如何借助云集群打造高性能计算

    云计算一开始致力于为互动系统(systems of engagement)改善应用架构,而在高性能计算方面提供不了什么。而如今,领先的云服务提供商正在重构解决方...

    静一
  • C++| n阶汉诺塔问题(递归)

    cout<<"make "<<n<<" move to "<<y<<" from "<<x<<endl;

    星辉
  • 自动调优数据科学:新研究使机器学习流线化

    一个新的自动化机器学习系统比它的人类同行表现得更好,并且工作速度提高了100倍。 数据科学既是一门学科又是一个应用程序。它最近的飞速发展可以部分归因于其强大的问...

    人工智能快报
  • 如何将HTML字符转换为DOM节点并动态添加到文档中

    将字符串动态转换为DOM节点,在开发中经常遇到,尤其在模板引擎中更是不可或缺的技术。 字符串转换为DOM节点本身并不难,本篇文章主要涉及两个主题:<br />

    用户1631416
  • Elasticsearch+Kafka整合

    sparkle123
  • 万亿市场洞察:中国网民“夜经济”白皮书(完整版)

    ? 向深夜进发。 “夜经济”正在成为最热门的消费市场词汇之一。在不同的预测中,中国夜间经济未来的总体规模,被认为会超过万亿,甚至达到十万亿。 “夜经济”本质上...

    腾讯文旅

扫码关注云+社区

领取腾讯云代金券