并发编程（volatile关键词，实现重入锁）

1.关键词volatile的理解

首先我们看看如下代码：

public class Voliate {
    private static int MAX_VALUE = 5;
    private static int init_value = 0;

    public static void main(String[] args) {
        new Thread(()->{
            int localValue = init_value;
            while (localValue <= MAX_VALUE){
                if(init_value != localValue){
                    System.out.println("the init_value is updated : " + init_value);
                    localValue = init_value;
                }
            }
        },"Reader").start();

        new Thread(()->{
            int localValue = init_value;
            while (localValue <= MAX_VALUE){

                    System.out.println("the init_value is changed : " + localValue ++);
                    init_value = localValue;

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Updater").start();
    }

}

按照我们的想法我们可以以为上面的结果可能第一个线程和第二个线程都有会打印值，但是真实的结果是无论怎么运行只有第二个线程打印了信息：

从上面的结果可以看出来对于上面的线程，在下面线程进行值的更改后它并没有感知到值的变化，因此无法打印信息，那么接下来我们修改一下代码：

private static int init_value = 0;

改为

private static volatile int init_value = 0;

再看运行结果：

可以看到两个线程的打印信息都有了，这里我们可以看出来在第二个线程进行更改值后第一个线程立马就能读取到修改后的值；

接下来我们看看这个到底是怎么回事：

1.1 首先我们了解下CPU cache 模型

CPU缓存现在主流的是3级缓存,越靠近CPU的缓存读写速度越快，L1缓存被分为L1i和L2i这两个缓存是有专门的缓存用途。

CPU操作自身缓存的速度远大于操作主内存的速度，CPU cache模型只要是为了解决CPU直接读取主内存效率低而设计的；

那么在程序运行的过程中，CPU会将运算所需要的数据复制一份到CPU cache中，运算只是对CPU cache中的数据进行操作，操作完后再将CPU cache中的数据回写到主存当中，CPU和主存的交互如下：

 

1.2 Java内存模型

与CPU cache类似，它又如下规定：

1） 共享变量存储于主内存中，所有的线程都可以进行访问

2） 每个线程都有自己的私有的工作内存称之为本地内存

3） 工作内存只存储该线程对共享变量的副本

4）线程不能操作主内存变量只能操作本地内存的变量副本

模型图如下：

程序运行是，他也是通过和CPU cache一样的操作，先将所需数据复制到本地的内存中，然后操作本地内存的数据，之后在回写到主内存当中；

可能在真实的情况下，程序运用到了上面的这两种缓存模型，他们的交互图如下：

由上图可以看出来，由于程序的运行经历的这么多的缓存，那么在多线程的情况下肯定会出现缓存不一致的问题，这就导致了之前的第一个线程无法正常打印日志信息的问题；

那么使用volatile后他是如何正常打印，以及volatile起到了什么作用呢？

1.3  volatile的作用

       Java使用volatile来保证可见性，当一个变量被volatile修饰后，这个变量就是共享资源，在多线程环境下，当一个线程对这个共享对象进行修改后，他会立马回写修改内容到主存中并且他会告诉其他线程（即CPU）他们的缓存中的此共享对象是已经失效了，需要重新去获取，其他线程知道这个消息后会立马去主存中获取这个最新的数据，因此就到达了数据可见性的效果

针对上面我们的例子理解volatile作用

1). 第一个线程从主存中获取init_value为0，并且将它缓存到本地内存当中

2).第二个线程将本地内存中的init_value变为1然后立即刷新到主存当中

3).第一个线程本地的init_value缓存失效，立即过去主存中的数据，拿到最新的值

 

2.通过继承Lock接口如何实现自定义锁

package com.lsm.thread.thread.t1.util;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自定义锁
 */
public class MyLock implements Lock{

    private boolean isLocked = false;

    @Override
    public synchronized void lock() {
        /**
         * 自旋判断是否锁已被释放
         */
        while (isLocked){
            try {
                wait();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        /**
         * 更新锁的状态
         */
        isLocked = true;
    }


    @Override
    public synchronized void unlock() {
        isLocked = false;
        /**
         * 唤醒其他线程进行锁的获取
         */
        notify();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

这里我们只重写lock()方法和unlock()方法，代码简单一目了然

接下里我们看测试类：

 private MyLock myLock = new MyLock();

 public void aAdd(){
        myLock.lock();
        a++;
        myLock.unlock();
    }

    public void printA(){
        myLock.lock();
        System.out.println(" a is : " + a);
        myLock.unlock();
    }
public static void main(String[] args) {
        Threadt4 threadt4 = new Threadt4();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " : " );
                threadt4.aAdd();
            }
        });
        thread.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " : " );
                threadt4.printA();
            }
        }).start();
    }

上面我们是定义了一把公共的锁以及一个数据自增以及获取数据的方法，程序正常运行,结果正常：

但我们上面的自定义锁无法实现锁重入如下图：

public void getA(){
        myLock.lock();
        System.out.println("this is a : ");
        
        /**
         * 再a中调用使用了同一把锁的b（）方法：模拟锁重入
         */
        getB();
        myLock.unlock();
    }


public void getB(){
        myLock.lock();
        System.out.println("this is b");
        myLock.unlock();
    }


public static void main(String[] args) {
        Threadt4 threadt4 = new Threadt4();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                threadt4.getA();
            }
        });
        thread.start();
    }

如上面的代码我们在使用mylock锁的a方法中调用同样使用mylock的b方法，模拟了锁重入，运行结果如下

当他执行了a方法后，程序一直待运行，原因是因为在a方法调用了mylock的lock()方法后在未执行unlock方法释放锁之前调用了b方法，而此时b.lock（）方法一直在等待这a释放锁，因此b程序一直在等待资源释放，a也一直在等待的b执行完毕，因此就出现了方法无法正常结束；

那么我们该如何实现一个可重入锁呢？

2.1 什么是重入锁？

重入锁是，一个同一个线程在调用使用同一把锁的资源时可立即获取到锁而不造成线程阻塞（可根据上面的代码理解：getA()和getB()是使用了同一把锁的资源；

实现原理：

我们需要在锁中判断是否当前的线程是否是上一次获取了锁的线程，如果是那么我们就让他执行下面的操作，如果不是我们将让他等待上一个线程释放资源后再竞争锁；以及我们记录下当前线程重复多少次持有这把锁，当重复获取到的锁都释放后才最终的将这把锁释放

对MyLock.java改动如下

package com.lsm.thread.thread.t1.util;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自定义锁
 */
public class MyLock1 implements Lock{

    private boolean isLocked = false;
    private Thread lastThread = null;
    private int count  = 0;

    @Override
    public synchronized void lock() {
        
        Thread currentThread = Thread.currentThread();

        /**
         * 自旋判断是否锁已被释放
         * 判断释放线程和上一个获取锁的线程一致
         */
        while (isLocked && !currentThread.equals(lastThread)){
            try {
                wait();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lastThread = currentThread;
        count ++;

        /**
         * 更新锁的状态
         */
        isLocked = true;
    }


    @Override
    public synchronized void unlock() {
        Thread currentThread = Thread.currentThread();
        /**
         * 只有同一个线程才能进行锁的释放不是的话，跳过
         */
        if(currentThread.equals(lastThread)){
            count -- ;
            if(count == 0){
                isLocked = false;
                /**
                 * 唤醒其他线程进行锁的获取
                 */
                notify();
            }
        }
        
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

主要改动是加上了一个线程的变量用来记录和判断是否当前的线程是已获取锁的线程，以及一个记录当前线程重复持有锁的次数；

再执行上面的测试我们将发现程序不会一直等待，完美运行

到这里我们了解到基本的重入锁，也实现了一个简单的重入锁；