ReentrantLock（重入锁）

ReentrantLock

先看一段程序：

public class DemoT {
    //    定义一个共享变量
    private static int count = 0;

    //  用来操作共享变量的方法
    public static void inc() {
        try {
//           为了展示出多线程同时操作同一数据会出现问题。如果去掉之后可能会正常计算出数据
            Thread.sleep(1);
            count++;
//            decr();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }


    public static void main(String[] args) throws InterruptedException {
//        新建三个线程 每个循环100遍，去调用inc方法操作共享变量
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread.start();
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread2.start();
        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread3.start();
//        保证三个子线程已经运行结束
        Thread.sleep(2000);
//        打印共享变量
        System.out.println("count:" + count);
    }
}

想要的结果：（打印：count:300）

实际打印结果：count:285（可能不是285，但是基本上都是小于300）

添加重入锁（ReentrantLock）（还是之前的代码只不过加了一把锁）

public class DemoT {
    //    定义一个共享变量
    private static int count = 0;

    //添加重入锁   @param fair {@code true} if this lock should use a fair ordering policy(译：@param fair{@code true}如果此锁应使用公平排序策略)
//    如果添加true 则是使用公平锁，否则为非公平锁
    static Lock lock = new ReentrantLock(true);


    //  用来操作共享变量的方法
    public static void inc() {
        lock.lock(); //获得锁(互斥锁)  
        try {
//           为了展示出多线程同时操作同一数据会出现问题。如果去掉之后可能会正常计算出数据
            Thread.sleep(1);
            count++;
//            decr();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//释放锁
        }
    }


    public static void main(String[] args) throws InterruptedException {
//        新建三个线程 每个循环100遍，去调用inc方法操作共享变量
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread.start();
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread2.start();
        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread3.start();
//        保证三个子线程已经运行结束
        Thread.sleep(2000);
//        打印共享变量
        System.out.println("count:" + count);
    }
}

运行得到：count:300

实现想要的结果，所以这是一个互斥锁，只允许一个线程进入当前范围

那为什么他叫“重入”呢？是因为他可以获得当前锁的情况下，还可以进入另外一个以当前锁为锁头的代码块。例如下面代码：（还是之前代码，只不过添加了一个方法体用来对共享变量递减）

public class DemoT {
    //    定义一个共享变量
    private static int count = 0;

    //添加重入锁   @param fair {@code true} if this lock should use a fair ordering policy(译：@param fair{@code true}如果此锁应使用公平排序策略)
//    如果添加true 则是使用公平锁，否则为非公平锁
    static Lock lock = new ReentrantLock(true);


    //  用来操作共享变量的方法
    public static void inc() {
        lock.lock(); //获得锁(互斥锁)  
        try {
//           为了展示出多线程同时操作同一数据会出现问题。如果去掉之后可能会正常计算出数据
            Thread.sleep(1);
            count++;
            decr();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//释放锁
        }
    }

    public static void decr() {
        lock.lock(); //state=2   //ThreadA再次来抢占锁 : 不需要再次抢占锁，而是只增加重入的次数
        try {
            count--;
        } finally {
            lock.unlock(); //state=1
        }
    }

    public static void main(String[] args) throws InterruptedException {
//        新建三个线程 每个循环100遍，去调用inc方法操作共享变量
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread.start();
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread2.start();
        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                DemoT.inc();
            }
        });
        thread3.start();
//        保证三个子线程已经运行结束
        Thread.sleep(2000);
//        打印共享变量
        System.out.println("count:" + count);
    }
}

预计结果：count:0

实际运行结果：count:0

概念

重入是如何实现的？

内部有一个 volatile 修饰的变量，当当前线程添加一把锁变量+1 ，当变量结束一个锁，则-1；当为0 说明当前线程无当前锁
 volatile int waitStatus;

没有获取到当前锁的线程怎么操作？以及是怎么保存的？

会放在一个双向链表 使用 addWaiter 将未获得锁的线程加入到队列 

并且区分公平锁和非公平锁

非公平锁：如果当前线程执行到锁的位置，直接去抢占锁，如果抢到，直接拿到锁，运行。链表队列中继续等待。

公平锁：如果当前线程执行到锁的位置，先去链表中判断是否存在其他线程，如果存在，加入队列末尾。如果不存在，去判断锁是否被其他线程拿到，如果有，添加到链表队列，没有执行代码块。