多线程与高并发之（二）volatile与CAS

volatitle

volatile关键字，使一个变量在多个线程可见
A，B线程公用一个变量，java默认A是线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
使用volatile关键字，将会强制所有的线程去堆内存中读取变量的值，会让所有线程都会读到变量的修改值。
但是volatile并不能保证多线程操作变量最终的一致性，它不能替代synchronized

package com.learn.thread.second;

public class HelloVolatile {

    /**
     * volatile 关键字会让所有线程去对象的堆内存中读最新的数值，默认情况下，每一个线程都会有自己的cpoy
     */
    private volatile boolean running = true;

    void m() {
        System.out.println("m.start");
        while (running) {

        }
        System.out.println("e.end");
    }

    public static void main(String[] args) {
        HelloVolatile helloVolatile = new HelloVolatile();
        new Thread(() -> {
            helloVolatile.m();
        }).start();
        new Thread(() -> {
            helloVolatile.m();
        }).start();
        // 这里延迟一秒
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        helloVolatile.running = false;
    }
}

保证线程的可见性

正如前面提到的那样，java的对象是存放在堆内存中的，是所有线程共享的内存，除了这个共享的内存，每一个线程都有自己的专属区域，就是自己的工作内存，如果对象堆内存中有一个值的话，当线程去访问的时候会将这个值cop一份，copy到自己的工作空间里头，然后对这个值的改变，首先是在自己的空间进行改变，什么时候写回去，就是改完之后写回去。所以说，什么时候去校验最新的值，volatile并不好控制。
这里就是典型的，一个线程修改值，另外一个线程并不能感知，加了volatile关键字，让所有线程去读取堆内存最新的值

禁止指令重新排序（volatile的第一层含义）

指令重排序也是和cpu有关系，每次写都会被线程读到，加了volatile之后，cpu原来执行一条执行的时候它是一步步顺序的执行，但是现在的cpu为了提高效率，它会把命令并发的执行。第一个指令执行到一半的时候第二个指令可能就已经开始执行了，这就叫做流水线式的执行。在这种新的架构的设计基础之上呢想充分利用这一点，那么要求你的编译器把你的源码编译完的指令之后可能进行一个重新排序。

单例模式（volatile的第二层含义）

之前文章说到过单例模式，就是保证JVM的内存里头永远只有一个类的实例，最简单的单例模式就是饿汉式。但是我们来聊聊吹毛求疵的懒汉式单例模式和双重校验锁的单例模式。

package com.learn.thread.second;

public class TestVolatile {
    // 不作为常量进行实例化
    private static TestVolatile layzerSingleton = null;

    private static volatile TestVolatile instance = null;

    private TestVolatile(){

    }

    /**
     * 懒汉式单例模式存在性能问题
     * 这种写法是有问题的
     *
     * @return
     */
    public static TestVolatile getInstance(){
        if (layzerSingleton == null){
            synchronized (TestVolatile.class) {
                layzerSingleton = new TestVolatile();
            }
        }
        return layzerSingleton;
    }

    /**
     * 双重校验锁
     *
     * @return
     */
    public static TestVolatile getVolatileInstance(){
        if (instance == null){
            synchronized (TestVolatile.class) {
                instance = new TestVolatile();
            }
        }
        return instance;
    }
}

首先我们的第一种懒汉式单例是有问题的
我们分析一下，首先两个线程都定留在了判断为空的命令上，第一个线程对实例加了锁，但是第二个线程是不知道第一个线程往实例加了锁的！！！，它要等第一个线程synchronized完了以后释放锁才知道，所以第二个线程会继续向下执行，把锁重新初始化了一遍。

我们再来看看第二个双重校验锁。
还是之前的场景，但是和之前的不同时，第二个线程在判断条件不会下不会继续往下执行，原因是volatile是禁止指令重排序的，一般instance = new Instance经过编译器编译后就是三个步骤 1.给指令申请内存空间 2.给成员变量初始化 3.将这块内存的内容赋值给成员变量，第二个线程的指令必须等第一个线程指令执行完了再执行，所以第二个线程判断的时候，锁实例肯定是有值的，永远不会进去锁的那部分代码！

我们再来看看，volatile不能替代synchronized的程序

package com.learn.thread.second;

import java.util.ArrayList;
import java.util.List;

public class T {

    volatile int count = 0;

    synchronized void m() {
        for (int i=0; i < 10000; i++) {
            count ++;
        }
    }

    public static void main(String[] args) {
        T t = new T();
        List<Thread> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            list.add(new Thread(() -> t.m()));
            list.forEach(item -> {
                try {
                    item.start();
                }catch (Exception ex) {

                }
            });
        }


        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(t.count);
    }
}

如果把m方法的synchronized去掉，这个程序的结果将达不到10万。这说明了volatile不能替代synchronized。

锁优化

锁优化其中有一个叫做锁粒度变细，还有一个叫做锁粒度变粗，就是说作为synchronized这个锁征用不是很剧烈的前提下，这个锁的粒度要小一点，来看一下什么时候要锁粗一点，什么时候锁细一点。
下面我们看一个程序

package com.learn.thread.second;

public class FineCoarseLock {
    
    int cout = 0;
    
    synchronized void m1() {
        // 模拟一段业务逻辑
        try {
            Thread.sleep(1000);
        }catch (Exception ex) {
        }
        // 其实要锁的也就这一行逻辑（所以应该锁细化，不应该synchronized放在方法上）对比m2
        cout ++;
        // 业务处理之后
        try {
            Thread.sleep(1000);
        }catch (Exception ex) {
        }
    }
    
    void m2() {
        // 模拟一段业务逻辑
        try {
            Thread.sleep(1000);
        }catch (Exception ex) {
        }
        // 
        synchronized (this) {
            cout ++;
        }
        // 业务处理之后
        try {
            Thread.sleep(1000);
        }catch (Exception ex) {
        }
    }
}

上述代码就是一个锁粒度变细的优化，但是如果你的业务逻辑代码充满了各种细锁，那么这时候你就该考虑在整个业务方法加synchronize把锁变粗

下面我们再看一个对象锁锁不住的情况

package com.learn.thread.second;

import java.util.concurrent.TimeUnit;

public class TestObjectLock {
    Object a = new Object();

    void m() {
        synchronized (a) {
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {

            }
            System.out.println(Thread.currentThread().getName());
        }
    }

    void m2() {
        synchronized (a) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {

            }
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        TestObjectLock test = new TestObjectLock();
        new Thread(()->{
            test.m();
        },"t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {

        }
        // 注意这里改变了所对象的引用，所以会导致锁失效
        test.a = new Object();
        new Thread(()->{
            test.m2();
        },"t2").start();
    }
}

注意这里如果放开了，则对象锁失效，t2先进来，所以没放开就对象锁有效，t1 t2顺序执行

我们稍微回顾一下synvhronized和volatile

• synchronized锁的是对象而不是代码，锁方法锁的是this，锁static是锁Class，锁方法和非锁方法是可以同时执行的，锁升级从偏向锁大自旋锁到重量级锁。
• volatile保证了线程的可见性，同时防止指令重排序，线程可见性在CPU级别是用缓存一直来保证的，所以禁止CPU级别的重排序是禁止不了的，但是在虚拟机加volatile这个指令重排序就可以禁止。严格来将是jvm加了读屏障和写屏障，这是CPU的一个原语。

CAS

CAS号称无锁优化，或者叫自旋。我们通过Atomic类（原子类）。由于某一些特别常见的操作，老是来回的加锁，加锁的情况特别多，所以干脆java就提供了这些常见操作的类，这些类的内部就带了锁，但是这些锁并不是synchronized重量级锁，而是通过无锁实现的

下面我们举几个例子，凡是以Atomic开头的都是CAS这种操作保证线程安全的类，AtomicInteger的意思就是里面包了一个int类型，这个int类型的自增count++是线程安全的，还有拿值都是安全的，因为我们日常开发中需要这种线程安全的类，所以jdk为我们提供了这样的一些类，使用AtomicInteger的方法如下所示。

package com.learn.thread.second;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 测试AmoticInteger
 */
public class TestAmoticInteger {
    
    // 如果使用Amotic 则可以加到10000
    AtomicInteger count = new AtomicInteger(0);
    
/*    // 如果不使用Amotic 则可以不加到10000
    Integer count = new Integer(0);*/
    void m() {
        for (int i = 0; i < 10000;i++) {
            // +1
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        TestAmoticInteger amoticInteger = new TestAmoticInteger();
        List<Thread> threads = new ArrayList<>(16);
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(() -> amoticInteger.m(), " thread  " + i));
        }
        
        threads.forEach(item -> item.start());
        threads.forEach(item -> {
            try {
                item.join();
            }catch (Exception ex) {
                ex.printStackTrace();
            }
        });

        System.out.println(amoticInteger.count);
    }
}

下面我们聊聊Amotic 的原理CAS（compareAndSetInt）操作。

    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

主要看unsafe这个getAndAddInt方法，意思就是我想改变某一个值0，把它变成1，于是就有这样 一个方法
cas(V,Expected,NewValue)
if V== E
V = NewValue
otherwise try again or fail
V第一个参数是要改变的那个值，Expected第二个参数是期望当前的值是几，NewValue要设定的新值，当前这个线程要想改这个值的时候我期望这个值就0，你不能是个1，如果是1就说明我这值不对。比如原来这个值变成3了，我这个线程想改这个值的时候一定是期望你现在是3，是3我才去改，但是如果我改的过程中，变成4了，那你就跟我期望值对不想，那我就cas重新再试一下，注意这时候我希望你这个值是4，是4我才改，不是4我再cas重新试一下或者失败。
注意CAS是CPU原语支持的，也就说说CAS操作是CPU指令级别上的支持，中间不能被任何指令打断。

面试题值ABA问题
这个问题产生的原因就是说你拿到一个值1，你想改成2，你用cas操作，期望值是1，准备变成2，但是有一个线程之前就已经把1变成了2又变成了1，如果你的数据类型是基础类型的话，那么cas不会有影响，但是如果你的数据类型是引用类型的话，对象的引用地址不同。所以如果要解决这个问题可以加版本号，对任何一个值的改变版本号就加1，后面查询的时候连带版本号一起查。

你可能会问不加锁是怎么做到线程安全的，原因是使用了Unsafe这个类，这个类是给反射用的，和ClassLoad是有关系的。所有的Amotic操作内部下面都是CompareAndSetInt这样的操作。

总结

回顾我们今天的内容，我们将了volatile（1，线程可见性，2，禁止指令重排序），将了CAS原理，CAS产生的ABA问题，Unsafe了解。