Java多线程21 JMM与Lock

II. 缓存一致性
MESI协议中的缓存状态

状态	含义	监听任务
M 被修改 Modified	因为缓存行刚被修改，数据应是独一无二的，与主存中的数据不一致，与其他CPU的缓存中对应数据也不相同。但是一定会在将来某个时间点写回主存中，这个时间点一定是在其他CPU读取自己的(主存相应的)缓存之前。	被修改的缓存行必须时刻监听所有想读该缓存行对应的主存/其他CPU缓存的操作，因为要确保在CPU读取操作之前把被修改的缓存行写回主存并将状态变为 S。
E 独享的 Exclusive	被修改状态的缓存行要将数据写回主存，此时可以认为是独享的状态。只有自己的缓存和主存中数据一致，其他CPU对应的缓存行还没有更新。但是一定会在将来其他CPU读取对应的缓存行之前变为共享状态。	独享的缓存行也必须监听其他CPU缓存读取主存中对应缓存行的操作，一旦有了这种操作，该缓存行需要变成 S 状态。
S 共享的 Shared	该状态意味该缓存行可能被多个CPU缓存，并且各个缓存中的数据与主存中的数据是一致的。当有一个CPU修改了该缓存行中的数据，该缓存行变为被修改状态，其他CPU中对应的缓存作废，变为无效状态 I。	对于该缓存行来说，要监听其他缓存使该缓存行无效。
I 无效的	Invalid 缓存行作废，无效。

image.png

Heap（堆）：java 里的堆是一个运行时的数据区，堆是由垃圾回收来负责的，堆的优势是可以动态的分配内存的大小，生存期也不必事先告诉编译器，因为他是在运行时动态分配内存的，java的垃圾回收器会定时收走不用的数据，缺点是由于要在运行时动态分配，所有存取速度可能会慢一些。
Stack（栈）：栈的优势是存取速度比堆要快，仅次于计算机里的寄存器，栈的数据是可以共享的，缺点是存在栈中的数据的大小与生存期必须是确定的，缺乏一些灵活性
栈中主要存放一些基本类型的变量，比如int，short，long，byte，double，float，boolean，char
对象句柄。

Java内存模型
Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。执行线程必须先在自己的工作线程中对变量i所在的缓存行进行赋值操作，然后再写入主存当中。

原子性：Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

x = 10; //语句1
y = x; //语句2
x++; //语句3
x = x + 1; //语句4

1)语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中。
2)语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及 将x的值写入工作内存 这2个操作都是原子性操作，但是合起来就不是原子性操作了。
3)同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值。所以上面4个语句只有语句1的操作具备原子性。

可见性
Java提供了volatile关键字来保证可见性。当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

有序性
在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在Java里面，可以通过volatile关键字来保证一定的“有序性”。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

    private volatile boolean stop = false;

    public void shutDown() {
        stop = true;
    }

    public void doWork() {
        while (!stop) {
        }
        System.out.println("你能读到我们...");
    }

    public static void main(String[] args) throws InterruptedException {
        Volatile01 volatile01 = new Volatile01();
        new Thread(() -> {
            volatile01.doWork();
        }).start();

        Thread.sleep(2000);

        new Thread(() -> {
            volatile01.shutDown();
        }).start();
    }

运行结果：

你能读到我们...

去掉volatile在去执行
运行结果无输出

方法和代码块（对象锁和类锁）：
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象。

public class Sync01 implements Runnable{
    static int i = 0;
    @Override
    public void run() {
        add();
    }

    private synchronized void add(){
        for(int j = 0;j < 10000;j++){
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Sync01 sync01 = new Sync01();
        Sync01 sync02 = new Sync01();

        Thread thread = new Thread(sync01);
        Thread thread2 = new Thread(sync02);

        thread.start();
        thread2.start();

        thread.join();
        thread2.join();

        System.out.println(i);
    }
}

结果输出 值<20000

添加static关键字

    private synchronized static void add(){
        for(int j = 0;j < 10000;j++){
            i++;
        }
    }

结果输出 值=20000

    private void add() {
        synchronized (Sync01.class) {
            for (int j = 0; j < 10000; j++) {
                i++;
            }
        }
    }

    private void add() {
        synchronized (this) {
            for (int j = 0; j < 10000; j++) {
                i++;
            }
        }
    }

结果输出 值<20000

public class ReentrantLock01 {

    static int i = 0;

    public ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock01 reentrantLock01 = new ReentrantLock01();
        ReentrantLock01 reentrantLock02 = new ReentrantLock01();
        new Thread(() -> {
            reentrantLock01.add();
        }).start();
        //Thread.sleep(1000);
        new Thread(() -> {
            reentrantLock02.add();
        }).start();
        Thread.sleep(1000);
        System.out.println(i);
    }

    private void add() {
        try {
            lock.lock();
            for (int j = 0; j < 10000; j++) {
                i++;
            }
        } finally {
            lock.unlock();
        }
    }
}

结果输出 值=20000

public class ReentrantLock04 implements Runnable {

    public static ReentrantLock reentrantLock = new ReentrantLock();
    @Override
    public void run() {
        try{
            if(reentrantLock.tryLock(5, TimeUnit.SECONDS)){
                Thread.sleep(6000);
                System.out.println("获取");
            }else {
                System.out.println("获取失败");
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            if(reentrantLock.isHeldByCurrentThread()){
                reentrantLock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
     ReentrantLock04 reentrantLock04 = new ReentrantLock04();
        IntStream.range(0,2).forEach(i->new Thread(reentrantLock04){}.start());

    }
}

结果输出

获取失败
获取

Synchronized和ReetrantLock区别

实现方式

Lock是代码级别的，synchronized是JVM级别的

公平

     Lock可以是公平所，也可以是不公平锁，默认是非公平锁，synchronized是非公平锁

释放

     Lock的释放必须手动调用unlock()方法，而synchronized在代码出了代码块或方法之后就会自动释放锁。

等待中断

     Lock中如果持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，但是synchronized不会

条件变量

     Lock中可以有多个Condition来实现线程间通信，而synchronized是能通过当前锁来进行线程通信。

什么时候选择用ReetrantLock代替Synchronized

1、 在确实需要一些synchronized锁没有的特性的时候，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票的时候

2、 优先推荐synchronized开发，如果事实证明synchronized确实不合适，再用ReetrantLock开发。