浅析ReentrantLock可重入锁

2017-09-15 本文已影响102人薛云龙

Lock锁接口在JAVA SE5之后,出现在并发包中.它提供了与synchronized关键字一样的同步功能.只是在使用时需要显式地获取和释放锁，缺点就是缺少像synchronized那样隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性，可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。

可重入锁和不可重入锁

可重入锁:一个线程调用一个加锁的方法后,还可以调用其他加同一把锁的方法.
不可重入锁:一个线程获取到一把锁之后,该线程是无法调用其他加了该锁的方法.这种情况,容易造成死锁.比如:方法一添加了不可重入锁,方法二添加了不可重入锁,并且调用了方法一.这种情况下,调用方法二就会出现死锁的情况.那么.重入锁就可以避免这种情况.
常用的可重入锁:
Sychronized,java.util.concurrent.locks.ReentrantLock

ReentrantLock基本使用

ReentrantLock对资源进行加锁,同一时刻只会有一个线程能够占有锁.当前锁被线程占有时,其他线程会进入挂起状态,直到该锁被释放,其他挂起的线程会被唤醒并开始新的竞争.

public class ReentrantLockExample {
    private ReentrantLock reentrantLock = new ReentrantLock();

    private void test(){
        reentrantLock.lock();
        System.out.println("进行原子操作");
        try {
            Thread.sleep(3000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        ReentrantLockExample reentrantLockExample = new ReentrantLockExample();
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Thread(reentrantLockExample::test));
        }
    }
}

通过控制台的输出信息可知:每隔三秒输出一次信息.

ReentrantLock很大程度的依赖了抽象类AbstractQueuedSynchronizer,这里需要先对AbstractQueuedSynchronizer进行了解.看我下面的这篇文章

ReentrantLock又有公平锁和非公平锁之分,所以可以看到在源码中有两个锁的实现

公平锁:每个线程的资源竞争是公平的.按照自身线程调用lock方法的顺序来获取锁,即先到先得.
非公平锁:每个线程的资源竞争是顺序不定,谁的优先级高,那么谁就会先获得锁.

ReentrantLock几个重要方法的剖析

构造方法:ReentrantLock的无参构造器,默认将局部变量sync赋值为NonfairSycn.

/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

lock():调用sycn内部类的lock方法.

1.获取一把锁,如果该锁没有被其他线程持有,则立即返回,并将锁计数器加一;
2.如果当前线程已经持有该锁,则将锁计数器加一,并立即返回.
3.如果该锁被其他线程持有,那么当前线程的目的将会无效并进入休眠状态.直到锁计数器的值为1.
public void lock() {
        sync.lock();
    }

这里先看一下,公平锁的lock方法的实现.

FairSync:默认调用AbstractQueuedSynchronizer的acquire()方法.
final void lock() {
            acquire(1);
        }
AbstractQueuedSynchronizer:
public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

非公平锁的lock方法实现:

NonfairSync:
final void lock() {
        //通过CAS操作,将AQS中的stateOffset从0改为1.
        if (compareAndSetState(0, 1))
             //将当前线程设为独享线程
              setExclusiveOwnerThread(Thread.currentThread());
        else
             //否则,再次请求同步状态.一般参数为0是释放锁,参数为1是获取锁
              acquire(1);
}
AbstractQueuedSynchronizer:其中tryAcquire()是由具体的实现类实现的.
public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
}
这里分为两步进行分析:
1.NonfairSync:执行tryAcquire方法
protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        //获取当前AQS的状态
        int c = getState();
        if (c == 0) {//同步状态为0时,执行CAS操作
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }//当前线程已经获取到锁,因为当前是重入锁,则state+1,并返回true
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
}
2.NonfairSync:tryAcquire方法返回false之后,会执行acquireQueued方法.
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        //尾节点不为空
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

因为NonfairSync是非公平锁,所以对于新来的线程和同步队列的线程,都能调用这个方法来获取到锁.
由于实现过于复杂,这里总结来说:当多个线程赖竞争锁时,只会有一个线程能够获取到锁,那么其他线程将会通过CAS操作(保证数据的一致性)来将当前线程添加到同步队列中,当所有线程进入到同步队列之后,就会进入自旋状态(死循环判断当前线程所在节点的前驱节点是否为head节点)去尝试获取同步状态.

lockInterruptibly()或者tryLock()
可中断的获取方式.两者最终都会调用方法:

private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

如果检测到线程的中断,将会直接抛出异常.

参考文章

浅析ReentrantLock可重入锁

猜你喜欢

热点阅读