多线程安全（二）volatile关键字

Java内存模型

共享内存模型指的就是Java内存模型(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

 

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

1. 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。

2. 然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

下面通过示意图来说明这两个步骤：

 

如上图所示，本地内存A和B有主内存中共享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存A中。当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。

总结：什么是Java内存模型：java内存模型简称jmm，定义了一个线程对另一个线程可见。共享变量存放在主内存中，每个线程都有自己的本地内存，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程安全问题。

 Volatile

什么是Volatile

Volatile 关键字的作用是变量在多个线程之间可见。

代码:

class ThreadVolatileDemo extends Thread {     public    boolean flag = true;     @Override     public void run() {         System.out.println("开始执行子线程....");         while (flag) {         }         System.out.println("线程停止");     }     public void setRuning(boolean flag) {         this.flag = flag;     }   }   public class ThreadVolatile {     public static void main(String[] args) throws InterruptedException {         ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo();         threadVolatileDemo.start();         Thread.sleep(3000);         threadVolatileDemo.setRuning(false);         System.out.println("flag 已经设置成false");         Thread.sleep(1000);         System.out.println(threadVolatileDemo.flag);       } }

运行结果:

 

已经将结果设置为fasle为什么？还一直在运行呢。

原因:线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。

解决办法使用Volatile关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值

 

Volatile非原子性

注意: Volatile非原子性

public class VolatileNoAtomic extends Thread {     private static volatile int count;       // private static AtomicInteger count = new AtomicInteger(0);     private static void addCount() {         for (int i = 0; i < 1000; i++) {             count++;             // count.incrementAndGet();         }         System.out.println(count);     }       public void run() {         addCount();     }       public static void main(String[] args) {           VolatileNoAtomic[] arr = new VolatileNoAtomic[100];         for (int i = 0; i < 10; i++) {             arr[i] = new VolatileNoAtomic();         }           for (int i = 0; i < 10; i++) {             arr[i].start();         }     }   }

运行结果:

 

结果发现 数据不同步，因为Volatile不用具备原子性。

使用AtomicInteger原子类

AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。

public class VolatileNoAtomic extends Thread {     static int count = 0;     private static AtomicInteger atomicInteger = new AtomicInteger(0);       @Override     public void run() {         for (int i = 0; i < 1000; i++) {             //等同于i++             atomicInteger.incrementAndGet();         }         System.out.println(count);     }       public static void main(String[] args) {         // 初始化10个线程         VolatileNoAtomic[] volatileNoAtomic = new VolatileNoAtomic[10];         for (int i = 0; i < 10; i++) {             // 创建             volatileNoAtomic[i] = new VolatileNoAtomic();         }         for (int i = 0; i < volatileNoAtomic.length; i++) {             volatileNoAtomic[i].start();         }     }   }

 

volatile与synchronized区别

仅靠volatile不能保证线程的安全性。（原子性）

①volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法

②volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。

synchronized不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时，会出现阻塞。

线程安全性

线程安全性包括两个方面，①可见性。②原子性。

从上面自增的例子中可以看出：仅仅使用volatile并不能保证线程安全性。而synchronized则可实现线程的安全性。

转载于:https://www.cnblogs.com/liclBlog/p/9379767.html