ReentrantLock可重入锁、公平锁非公平锁区别与实现原理

ReentrantLock是lock接口的一个实现类，里面实现了可重入锁和公平锁非公平锁

ReentrantLock公平锁和不公平锁实现原理

公平锁会获取锁时会判断阻塞队列里是否有线程再等待，若有获取锁就会失败，并且会加入阻塞队列

非公平锁获取锁时不会判断阻塞队列是否有线程再等待，所以对于已经在等待的线程来说是不公平的，但如果是因为其它原因没有竞争到锁，它也会加入阻塞队列

进入阻塞队列的线程，竞争锁时都是公平的，应为队列为先进先出（FIFO）

默认实现的是非公平锁

public ReentrantLock() {

    //非公平锁

    sync = new NonfairSync();

}

还提供了另外一种方式，可传入一个boolean值，true时为公平锁，false时为非公平锁

//公平锁

public ReentrantLock(boolean fair) {

    sync = fair ? new FairSync() : new NonfairSync();

}

非公平锁

非公平锁获取锁nonfairTryAcquire方法，对锁状态进行了判断，并没有把锁加入同步队列中

    static final class NonfairSync extends Sync {

        private static final long serialVersionUID = 7316153563782823691L;

        final void lock() {

            //比较当前状态 如果持有者是当前线程

            if (compareAndSetState(0, 1))

                setExclusiveOwnerThread(Thread.currentThread());

            else

                //如果不是 尝试获取锁

                acquire(1);

        }

        protected final boolean tryAcquire(int acquires) {

            //获取锁

            return nonfairTryAcquire(acquires);

        }

    }

final boolean nonfairTryAcquire(int acquires) {

            final Thread current = Thread.currentThread();

            int c = getState();

            //判断当前对象是否被持有

            if (c == 0) {

                //没有持有就直接改变状态持有锁

                if (compareAndSetState(0, acquires)) {

                    setExclusiveOwnerThread(current);

                    return 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;

        }

公平锁

代码和nonfairTryAcquire唯一的不同在于增加了hasQueuedPredecessors方法的判断

static final class FairSync extends Sync {

        private static final long serialVersionUID = -3000897897090466540L;

       protected final boolean tryAcquire(int acquires) {

           //获取当前线程

            final Thread current = Thread.currentThread();

            int c = getState();

            //判断当前对象是否被持有

            if (c == 0) {

                //如果等待队列为空 并且使用CAS获取锁成功   否则返回false然后从队列中获取节点

                if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {

                    //把当前线程持有

                    setExclusiveOwnerThread(current);

                    return true;

                }

            }

           //若被持有 判断锁是否是当前线程  可重入锁的关键代码

            else if (current == getExclusiveOwnerThread()) {

                //计数加1 返回

                int nextc = c + acquires;

                if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);

                return true;

            }

            //不是当前线程持有 执行

            return false;

        }

    }

acquire()获取锁

    public final void acquire(int arg) {

        //如果当前线程尝试获取锁失败并且 加入把当前线程加入了等待队列

        if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

            //先中断当前线程

            selfInterrupt();

    }

关键代码

就是tryAcquire方法中hasQueuedPredecessors判断队列是否有其他节点

public final boolean hasQueuedPredecessors() {

    Node t = tail; // Read fields in reverse initialization order

    Node h = head;

    Node s;

    return h != t &&

        ((s = h.next) == null || s.thread != Thread.currentThread());

}

可重入性实现原理

在线程获取锁的时候，如果已经获取锁的线程是当前线程的话则直接再次获取成功

由于锁会被获取n次，那么只有锁在被释放同样的n次之后，该锁才算是完全释放成功

1、获取锁方法

 protected final boolean tryAcquire(int acquires) {

           //获取当前线程

            final Thread current = Thread.currentThread();

            int c = getState();

            //判断当前对象是否被持有

            if (c == 0) {

              //...略

            }

           //若被持有 判断锁是否是当前线程  可重入锁的关键代码

            else if (current == getExclusiveOwnerThread()) {

                //计数加1 返回

                int nextc = c + acquires;

                if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);

                return true;

            }

            //不是当前线程持有 执行

            return false;

        }

每次如果获取到的都是当前线程这里都会计数加1

释放锁

protected final boolean tryRelease(int releases) {

    //每次释放都减1

    int c = getState() - releases;

    if (Thread.currentThread() != getExclusiveOwnerThread())

        throw new IllegalMonitorStateException();

    boolean free = false;

    //等于0才释放锁成功

    if (c == 0) {

        free = true;

        setExclusiveOwnerThread(null);

    }

    setState(c);

    return free;

}

如果锁被获取n次，也要释放了n次，只有完全释放才会返回false

巴特西

ReentrantLock可重入锁、公平锁非公平锁区别与实现原理

ReentrantLock公平锁和不公平锁实现原理

非公平锁

公平锁

关键代码

可重入性实现原理

最新文章

热门文章