java volatile 多线程_Java多线程之三volatile与等待通知机制示例

原子性，可见性与有序性

在多线程中，线程同步的时候通常须要考虑原子性，可见性与有序性java

原子性

原子性定义：一个操做或者多个操做在执行过程当中要么所有执行完成，要么所有都不执行，不存在执行一部分的状况。安全

以咱们在Java代码中常常用到的自增操做i++为例，i++实际上并非一步操做，而是首先对i的值加一，而后将结果再赋值给i。在单线程中不会存在问题，但若是在多线程中咱们考虑这样一个状况：i是一个共享变量，初始值为0，假设线程一以执行到某一步正好进行自增操做i++，恰好对i进行了加一可是还没将值从新赋给i，此时当前线程被cpu挂起，而另外一个线程二开始执行，恰好也对i进行了一个赋值操做i=10;，等线程一从新执行后会将i自增后的值1赋给i，此时至关于覆盖了线程二的赋值操做。此时将会产生线程不安全的状况。多线程

可见性

多个线程同时访问一个共享的变量的时候，每一个线程的工做内存有这个变量的一个拷贝，变量自己仍是保存在共享内存(堆)中。因此并非每一次一个线程修改了值后其余线程均可以当即取到修改后的值。可见性是指当其余的线程访问同一个变量时，当一个线程修改了这个变量的值，其余线程也可以当即看获得修改的值。dom

有序性

有序性是指程序的执行严格按照咱们写的代码的顺序进行执行。ide

指令重排

通常状况下，CPU和编译器为了提高程序执行的效率，会按照必定的规则容许对指令进行优化，即调整实际指令运行的顺序。指令重排不会对单线程的程序形成任何不利的影响，可是多线程环境下将会产生一些影响。指令重排的前提条件是指令调整后不会影响单线程程序的执行：测试

int i = 2; //statement 1

int j = 1;//statement 2

int k = i*j;//statement 3

在上面的代码中对于语句1和语句2相互之间没有任何依赖，因此可能发生指令重排，可是语句3和语句1,2都有关系，因此语句3必定是在语句1和语句2以后执行的。因此单线程状况下是绝对不会出现问题的。可是对于多线程可能就发生只是初始化了语句1或者语句2就执行语句3了。优化

要保证在多线程下线程安全，这三大性质都是必需要保证的，而一旦其中一项没法保证那么不是线程安全的。前面的synchronized关键字就是实现了这三大特性的。this

volatile

虽然已经有了synchronized关键字保证了线程安全须要的三大特性，可是在JDK1.8优化synchronized以前，synchronized关键字都是一个重量级的锁，对程序的效率有着比较大的影响。在java中还有一个synchronized关键字的轻量级的实现-volatile关键字。volatile关键字是在JDK1.5以后从新被重用的一个关键字，它能够保证上诉三大特性中的有序性和可见性，可是不能保证原子性，因此它其实是线程不安全的。spa

保证可见性

出现可见性的缘由在于私有栈帧中的值和公共堆中的共享值不一样得问题。线程

当一个线程在修改普通变量时，其余线程不能马上看到修改后的值，若是此时有其余线程读取该变量的值，实际上读到的是没有修改的值。

volatile关键字做用在于当要使用时强制从主内存中读取值，保证每次读取的都是公共内存中的值。

防止指令重排

内存屏障也称为内存栅栏或栅栏指令，是一种屏障指令，它使CPU或编译器对屏障指令以前和以后发出的内存操做执行一个排序约束。 这一般意味着在屏障以前发布的操做被保证在屏障以后发布的操做以前执行。

volatile关键字功能的实现既是经过内存屏障完成的，当使用volatile关键字修饰的变量进行读写是便会加上内存屏障来保证设计变量的操做顺序执行，须要注意的是其和synchronized关键字的同步是不同的。

为何不是原子性的？

实际上volatile关键字保证的事全部线程从主存中取到的值是最新的，可是多个线程修改了改变量的值并不会通知其余线程，除非其余线程再次从主存中取值。

在以上阶段中，好比存在两个线程且两个线程都已经加载了变量count的值，这时线程一将count修改成10，线程二将值修改成20，可是两个线程之间并不知道对方都改了值，而最终写到主存的值也是后写入的那一个，即始终都一个线程修改的值被覆盖，因此其并非原子性的。在涉及到多线程操做共享变量是仍是应该加锁进行操做。

synchronized和volatile关键字的比较

volatile关键字并非同步操做，其在多线程访问下不会进行阻塞，而synchronized关键字会发阻塞。

volatile关键字能保证有序性和可见性，但不能保证原子性。synchronized三种特性都能保证，因此synchronized是线程同步的，而volatile不是。

volatile是线程同步的轻量级实现，因此效率较之synchronized要高。

等待通知机制

在多线程程序中可能会存在多个程序相互配合完成一项功能，这是就须要线程之间进行通讯，在一个线程的工做完成后通知后续线程工做。一般状况下咱们能够在一个线程中进行一个while循环操做，设置一个标志flag，当该线程的前置线程完成后修改flag，后面的while获得这个标志后知道自身须要开始工做了，跳出循环。可是这种方法的劣势在于while循环使得该线程一个须要处于运行中，同时当多个线程相互之间都须要进行通讯时会使得程序变得极其复杂。为了解决这个问题，有人提出了一种等待通知机制。

等待通知机制是利用JDK中提供的API中的wait()和notify/notifyAll()方法来进行实现(实际上Lock类中的方法也能实现)，wait()方法是使得当前线程进入等待队列中，notify/notifyAll()是将等待的线程唤醒。

等待方

获取对象锁

若是条件不知足，调用对象的wait方法，被通知后依然要检查条件是否知足

条件知足之后，才能执行相关的业务逻辑

Synchronized(对象){

While(条件不知足){

对象.wait()

}

// do your working

}

通知方

得到对象的锁；

改变条件；

通知全部等待在对象的线程

Synchronized(对象){

业务逻辑处理，改变条件

对象.notify/notifyAll

}

实例

public class User {

private int age = 30;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

/**

* 一、获取对象锁

* 二、若是条件不知足，调用对象的wait方法，被通知后依然要检查条件是否知足

* 三、条件知足之后，才能执行相关的业务逻辑

*/

public synchronized void waitAge(){

System.out.println("age is " + this.age);

while(this.age >= 20){

//条件不知足

try {

System.out.println("current thread is waiting");

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

//知足条件后执行

System.out.println("current thread" + Thread.currentThread().getName() + " age is " + this.age);

}

/**

* 一、得到对象的锁；

* 二、改变条件；

* 三、通知全部等待在对象的线程

*/

public synchronized void changeAge(){

//修改条件

this.age = new Random().nextInt(20);

System.out.println("inform all thread");

//这里使用notifyAll()是由于notify()方法没法指定唤醒某一个线程，notify()的唤醒是随机的

//notifyAll()唤醒全部等待线程

notifyAll();

}

}

测试类：

public class WaitAndInform extends Thread{

private static User user = new User();

@Override

public void run() {

user.waitAge();

}

public static void main(String[] args) throws InterruptedException {

for(int i=0;i<=4;i++){

new WaitAndInform().start();

}

Thread.sleep(1000);

//修改条件 唤醒其余线程

user.changeAge();

}

}