深入理解ReentrantLock

1、ReentrantLock介绍

        ReentrantLock是一种基于AQS（Abstract Queued Synchronizer）框架的应用实现，是JDK中一种线程并发访问的同步手段，它的功能类似于synchronized是一种互斥锁，可以保证线程安全。相比于synchronized，ReentrantLock具备如下特定：

• 可中断
• 可以设置超时时间
• 可以设置为公平锁
• 支持多个条件变量
• 与synchronized一样，都支持可重入。

2、ReentrantLock与Synchronized的区别

• synchronized是JVM层次的锁实现，ReentrantLock是JDK层次的锁实现。
• synchronized的锁状态是无法在代码中直接判断的，但是ReentrantLock可以通过isLocked判断。
• synchronized是非公平锁，ReentrantLock既可以是公平也可以是非公平，默认是非公平锁。
• synchronized是不可被中断的，而ReentrantLock#lockInterruptibly方法是可以被中断的。
• 在发生异常时synchronized会自动释放锁，而ReentrantLock需要开发者在finally中释放锁。
• synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁，因为是栈结构，先进后出，而ReentrantLock对于已经在等待的线程是先来的线程先获得锁，是双向链表，从头节点开始的下一个节点第一个被唤醒。

3、ReentrantLock的使用

3.1、同步执行。类似于synchronnized

public class ReentrantLockDemo {


    private static Lock lock=new ReentrantLock();

    public static void main(String[] args) {
        
        //加锁
       lock.lock();
       try {
         //临界区 
       } finally {
         //解锁
         lock.unlock();
       }

    }

}

3.2、可重入

package juc.lock;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;
@Slf4j
public class ReentrantLockDemo {

    public static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        method1();
    }


    public static void method1() {
        lock.lock();
        try {
            log.debug("execute method1");
            method2();
        } finally {
            lock.unlock();
        }
    }
    public static void method2() {
        lock.lock();
        try {
            log.debug("execute method2");
            method3();
        } finally {
            lock.unlock();
        }
    }
    public static void method3() {
        lock.lock();
        try {
            log.debug("execute method3");
        } finally {
            lock.unlock();
        }
    }

}

3.3、可中断

package juc.lock;


import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLockDemo {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("t1启动.....");
            try {
                lock.lockInterruptibly();
                try {
                    log.debug("t1获得了锁");
                } finally {
                    lock.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("t1等送的过程中被中断");
            }
        }, "t1");
        lock.lock();
        try {
            log.debug("main线程获得了锁");
            t1.start();
            //先让线程t1执行
            Thread.sleep(1000);

            t1.interrupt();
            log.debug("线程t1执行中断");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

3.4、锁超时

package juc.lock;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLockDemo {

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {

            log.debug("t1启动...");
            // 注意： 即使是设置的公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
//            if (!lock.tryLock()) {
//                log.debug("t1获取锁失败，立即返回false");
//                return;
//            }

            //超时
            try {
                if (!lock.tryLock(1, TimeUnit.SECONDS)) {
                    log.debug("等待 1s 后获取锁失败，返回");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                return;
            }

            try {
                log.debug("t1获得了锁");
            } finally {
                lock.unlock();
            }

        }, "t1");


        lock.lock();
        try {
            log.debug("main线程获得了锁");
            t1.start();
            //先让线程t1执行
            Thread.sleep(2000);
        } finally {
            lock.unlock();
        }

    }

}

3.5、公平锁

package juc.lock;

import java.util.concurrent.locks.ReentrantLock;

import lombok.extern.slf4j.Slf4j;

/**
 * 公平锁
 */
@Slf4j
public class ReentrantLockDemo {

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock(true); //公平锁
        //ReentrantLock lock = new ReentrantLock(); //非公平锁

        for (int i = 0; i < 500; i++) {
            new Thread(() -> {
                lock.lock();
                try {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    log.debug(Thread.currentThread().getName() + " running...");
                } finally {
                    lock.unlock();
                }
            }, "t" + i).start();
        }
        // 1s 之后去争抢锁
        Thread.sleep(1000);

        for (int i = 0; i < 500; i++) {
            new Thread(() -> {
                lock.lock();
                try {
                    log.debug(Thread.currentThread().getName() + " running...");
                } finally {
                    lock.unlock();
                }
            }, "强行插入" + i).start();

        }

    }

}

4、ReentrantLock源码分析