多线程之volatile与synchronized(二)

JMM中主要是围绕并发过程中如何处理原子性，可见性和有序性三个特性来建立的。最终可以保证线程安全性，volatile和synchronized两个关键字又是我们最常碰到与最容易提到的关键字，这次放在一起来讲。

与文无关

线程安全性：当多个线程访问某个类的时候，不管运行环境采用何种调度方式或这些线程如何交替执行，并且在主调代码中不需要额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

原子性、可见性与有序性

首先来看一下这几个特性代表的具体含义。

• 原子性(Atomicity)：原子性是指，一个操作是不可中断的。即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

  JDK的包中提供了专门的原子包java.util.concurrent.atomic，synchronized关键字还有Lock来让程序在并发环境下具有原子性的特点。

• 可见性(Visibility):可见性是指当一个线程修改了共享变量的值，其它线程能立即得知这个修改。

  volatile,synchronized和final关键字能实现可见性。使用final关键字需要注意对象逃逸

• 有序性：如果再本线程内观察，所有操作都是有序的，如果再一个线程中观察另外一个线程，那么所有操作都是无序的。前半句是指“线程内表现为串行”，后半句是指“指令重排序”现象和“工作内存与主内存同步延迟现象”

  volatile和synchronized关键字可以线程之间操作的有序性。

Volatile

一个变量定义为volatile之后，它将具有两种特性：

1. 保证次变了对所有线程的可见性，一条线程修改了这个值，新值对其它线程是可以立即得知的。
2. 禁止指令重排优化。

volatile变量在写操作时候，会在写操作后加上store屏障指令，将本地内存刷新到主内存。
volatile变量读操作的时候，会在读操作之前加入一条load屏障指令，从主内存中读取共享变量。

关于JMM的8大操作指令，可以查看我的上篇文章，java内存模型。

volatile变量为什么在并发下不安全？

volatile变量在各个线程的工作内存中也可以存在不一致的情况，但由于每次使用之前都要刷新，执行引擎看不到不一致的情况，因此可以认为不存在一致性问题，但是Java里面的运算并非原子操作。

假如说一个写入值操作不需要依赖依赖这个值的原先值，那么在进行写入的时候我们就不需要进行读取操作。
写入操作对原本的值的时候没有要求，那么所有线程都可以写入新的值，虽然读取到的值是相同的，每个线程的操作也是正确的，但是最终结果却是错误的。

JMM

感兴趣的可以运行如下代码:

public class VolatileTest {
    public static volatile int count = 0;
    public static final int THREAD_COUNT = 20;

    public static void add(){
        count++;
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            });
            threads[i].start();
        }
        
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i].join();
        }        
        
        System.out.println(count);
    }
    
}
// 如果并发正确的话：应该是20000，但是每次运行结果都不到20000

Volatile适合做什么？

适合做标量，当一个线程对某个变量进行读写操作，而其它线程仅仅进行读操作的时候，是可以保证volatile的正确性的。如下：

volatile bool stopped;
public void stop(){
    stopped = true
}

while(!stoppped){
    // 执行操作
}

Synchronized

Synchronized保证了原子性，可见性与有序性，它的工作时对同步的代码块加锁，使得每次只有一个线程进入代码块，从而保证线程安全。synchronized反应到字节码层面就是monitorenter与monitorexit.

注意*：虽然synchonized关键字看起来是万能的，能保证线程安全性，但是越万能的控制往往越伴随着越大的性能影响。

Synchonzied用法

1. 实例方法上，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
2. 静态方法上，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
3. 实例方法代码块.
4. 静态方法代码块。

 //实例方法
 public synchronized void add(int value){
      this.count += value;
 }
 //静态方法
 public static synchronized void add(int value){
      count += value;
 }
 
 //实例方法代码块 
 public void add(int value){
   synchronized(this){
       this.count += value;   
    }
 }
 
 //静态方法代码块
 public class MyClass {

    public static synchronized void log1(String msg1, String msg2){
       log.writeln(msg1);
       log.writeln(msg2);
    }

  
    public static void log2(String msg1, String msg2){
       synchronized(MyClass.class){
          log.writeln(msg1);
          log.writeln(msg2);  
       }
    }
  }
  

Synchonzied案例

public class SynchronziedTest implements Runnable{
    static int i = 0;
    static int j = 0;
    static SynchronziedTest instance=  new SynchronziedTest();

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
    }

    public synchronized void increase(){
        i++;
    }

    public static void main(String[] args) throws InterruptedException {
        // 注意新建的线程指向的同一个实例，
        // 如果指向不同的实例，那么两个线程关注的锁就不是同一把锁，就会导致线程不安全
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        
        //错误的用法
//        Thread t3 = new Thread(new SynchronziedTest());
//        Thread t4 = new Thread(new SynchronziedTest());
        
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}
//结果为:200000

注意创建线程的时候指向同一个实例，才会锁住相同的对象。

最后

这次我们讲了线程安全性的基本原则，然后解释了volatile和synchronized关键字，多线程中不得不掌握的关键字。

参考

• 《实战Java高并发设计》
• 《深入理解JVM虚拟机》
• 《Java并发编程与高并发解决方案》