Java多线程之synchronized和volatile的比较

在做多线程并发处理时,经常需要对资源进行可见性访问和互斥同步操作。有时候,我们可能从前辈那里得知我们需要对资源进行 volatile 或是synchronized 关键字修饰处理。可是,我们却不知道这两者之间的区别,我们无法分辨在什么时候应该使用哪一个关键字。本文就针对这个问题,展开讨论。

happens-before 模型简介

如果你单从字面上的意思来理解 happens-before 模型,你可能会觉得这是在说某一个操作在另一个操作之前执行。不过,学习完 happens-before 之后,你就不会还这样理解了。以下是《Java 并发编程的艺术》书上对 happens-before 的定义:

在 JMM(Java Memory Model) 中,如果一个操作执行的结果需要对另一个操作可见,那么这两个操作之间必须存在 happens-before 关系。这里提到的两个操作既可以在一个线程之内,也可以是在不同的线程之间。

volatile 的内存语义

对于多线程编程来说,每个线程是可以拥有共享内存中变量的一个拷贝,这一点在后面还是会讲到,这里就不作过多说明。如果一个变量被 volatile 关键字修饰时,那么对这的变量的写是将本地内存中的拷贝刷新到共享内存中;对这个变量的读会有一些不同,读的时候是无视他的本地内存的拷贝的,只是从共享变量中去读取数据。

synchronized 的内存语义

我们说 synchronized 实际上是对变量进行加锁处理。那么不管是读也好,写也好都是基于对这个变量的加锁操作。如果一个变量被 synchronized 关键字修饰,那么对这的变量的写是将本地内存中的拷贝刷新到共享内存中;对这个变量的读就是将共享内存中的值刷新到本地内存,再从本地内存中读取数据。因为全过程中变量是加锁的,其他线程无法对这个变量进行读写操作。所以可以理解成对这个变量的任何操作具有原子性,即线程是安全的。

上面的一些说明或是定义可能会有一些乏味枯燥,也不太好理解。这里我们就列举一些例子来说明,这样比较具体和形象一些。

volatile 可见性测试

RunThread.java

public class RunThread extends Thread{

private boolean isRunning =true;

public boolean isRunning {

return isRunning; 

}

public void setRunFlag(booleanflag) { 

 isRunning = flag; 

}

@Override public void run { 

System.out.println("I'm come in...");

booleanfirst =true;

while(isRunning) {

if(first) { 

System.out.println("I'm in while..."); 

first =false

System.out.println("I'll go out.");

 }

 }

MyRun.java

publicclassMyRun{publicstaticvoidmain(String args)throwsInterruptedException { RunThread thread =newRunThread; thread.start; Thread.sleep(100); thread.setRunFlag(false); System.out.println("flag is reseted: "+ thread.isRunning); } } 对于上面的例子只是一个很普通的多线程操作,这里我们很容易就得到了 RunThread 线程在 while 中进入了死循环。
我们可以在 main 方法里看到一句 Thread.sleep(100) ,结合前面说到的 happens-before 内存模型,可知下面的 thread.setRunFlag(false) 并不会 happens-before 子线程中的 while 。这样一来,虽然主线程中对 isRunning 进行了修改,然而对子线程中的 while 来说,并没有改变,所以这就会引发在 while 中的死循环。
在这种情况下,线程工作时的内存模型像下面这样
在这里,可能你会奇怪,为什么会有两个“内存块”?这是出于多线程的性能考虑的。虽然对象以及成员变量分配的内存是在共享内存中的,不过对于每个线程而言,还是可以拥有这个对象的拷贝,这样做的目的是为了加快程序的执行,这也是现代多核处理器的一个显著特征。从上面的内存模型可以看出,Java的线程是直接与它自身的工作内存(本地内存)交互,工作内存再与共享内存交互。这样就形成了一个非原子的操作,在Java里多线程的环境下非原子的操作是很危险的。这个我们都已经知道了,因为这可能会被异步的读写操作所破坏。
这里工作内存被 while 占用,无法去更新主线程对共享内存 isRunning 变量的修改。所以,如果我们想要打破这种限制,可以通过 volatile 关键字来处理。通过 volatile 关键字修饰 while 的条件变量,即 isRunning。就像下面这样修改 RunThread.java 代码: privatevolatilebooleanisRunning =true; 这样一来, volatile 修改了 isRunning 的可见性,使得主线程的 thread.setRunFlag(false) 将会 happens-before 子线程中的 while 。最终,使得子线程从 while 的循环中跳出,问题解决。
下面我们来看看 volatile 是如何修改了 isRunning 的可见性的吧。
这里,因为 isRunning 被 volatile 修饰,那么当子线程想要访问工作内存中的 inRunning 时,被强制地直接从共享内存中获取。而共享内存中的 isRunning 被主线程修改过了,已经被修改成了  false  ,while 被打破,这样子线程就从 while 的循环中跳出来了。volatile 原子性测试

volatile 确实有很多优点,可是它却有一个致命的缺点,那就是 volatile 并不是原子操作。也就是在多线程的情况,仍然是不安全的。

可能,这个时候你会发问说,既然 volatile 保证了它在线程间的可见性,那么在什么时候修改它,怎么修改它,对于其他线程是可见的,某一个线程读到的都会是修改过的值,为什么还要说它还是不安全的呢?
我们通过一个例子来说明吧,这样更形象一些。大家看下面这样一段代码:

public class DemoNoProtected

staticclass MyThread extends Thread {staticintcount =0;privatestaticvoidaddCount{for(inti =0; i <100; i++) { count++; } 

System.out.println("count = "+ count); }

@Override public void run { addCount; } }

public static void main(String args) {

 MyThread threads =newMyThread[100];for(inti =0; i <100; i++) { threads[i] =newMyThread; }

for(int i =0; i <100; i++) { threads[i].start; } } }

count =300count =300count =300count =400......count =7618count =7518count =9918

这是一个未经任何处理的,很直白的过程。可是它的结果,也很直白。其实这个结果并不让人意外,从我们学习Java的时候,就知道Java的多线程并不安全。是不是从上面的学习中,你感觉这个可以通过 volatile 关键字解决?既然你这么说,那么我们就来试一试,给 count 变量添加 volatile 关键字,如下:

publicclassDemoVolatile{staticclass MyThread extends Thread {staticvolatileintcount =0; ... ... }publicstaticvoidmain(String args) { ... ... } } count =100count =300count =400count =200......count =9852count =9752count =9652......count =8154count =8054

不知道这个结果是不是会让你感觉到意外。对于 count 的混乱的数字倒是好理解一些,应该多个线程同时修改时就发生这样的事情。可是我们在结果为根本找不到逻辑上的最大值“10000”,这就有一些奇怪了。因为从逻辑上来说, volatile修改了 count 的可见性,对于线程 A 来说,它是可见线程 B 对 count 的修改的。只是从结果中并没有体现这一点。

我们说,volatile并没有保证线程安全。在上面子线程中的 addCount 方法里,执行的是 count++ 这样一句代码。而像 count++ 这样一句代码从学习 Java 变量自增的第一堂课上,老师就应该强调过它的执行过程。count++ 可以类比成以下的过程:

inttmp = count; tmp = tmp +1; count = tmp;

可见,count++ 并非原子操作。任何两个线程都有可能将上面的代码分离进行,安全性便无从谈起了。

所以,到这里我们知道了 volatile 可以改变变量在线程之间的可见性,却不能改变线程之间的同步。而同步操作则需要其他的操作来保证。

synchronized 同步测试

上面说到 volatile 不能解决线程的安全性问题,这是因为 volatile 不能构建原子操作。而在多线程编程中有一个很方便的同步处理,就是 synchronized 关键字。下面来看看 synchronized 是如何处理多线程同步的吧,代码如下:

publicclassDemoSynchronized{staticclass MyThread extendsThread {staticintcount =0;privatesynchronizedstaticvoidaddCount {for(inti =0; i <100; i++) { count++; } System.out.println("count = "+ count); }@Overridepublicvoidrun { addCount; } }publicstaticvoidmain(String args) { MyThread threads =newMyThread[100];for(inti =0; i <100; i++) { threads[i] =newMyThread; }for(inti =0; i <100; i++) { threads[i].start; } } } count =100count =200count =300......count =9800count =9900count =10000 通过 synchronized 我们可以很容易就获得了理想的结果。而关于 synchronized 关键字的内存模型可以这样来表示:
某一个线程在访问一个被 synchronized 修饰的变量时,会对此变量的共享内存进行加锁,那么这个时候其他线程对其的访问就会被互斥。  synchronized  的内部实现其实也是锁的概念。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值