java源码学习-ReentrantLock

上文AQS源码学习

ReentrantLock

private final Sync sync;

在可重入锁的源码中, 由内部类Sync确定了加锁和释放锁, 由NonfairSync和FairSync类继承Sync来实现非公平锁和公平锁的实现

Sync

Sync是一个继承了AQS类的内部抽象类, 定义了一个lock方法供子类去重写

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        final boolean nonfairTryAcquire(int acquires) {
        	// 非公平锁的尝试获取锁方法, 它与公平锁的方法的区别是在资源空闲时
        	// 公平锁会去排队获取资源, 而非公平锁会直接抢占这个资源
            final Thread current = Thread.currentThread();
            int c = getState();
            // 这个方法与tryAcquire的唯一区别就在这个if中
            if (c == 0) {
            	// 直接cas将状态设置为不为0, 尝试去抢夺资源
                if (compareAndSetState(0, acquires)) {
                	// 资源抢占成功后, 将该线程设置为正在使用锁的线程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 这里是可重入锁的判断, 该锁的使用线程是该线程时进入
            // 这里也就是有多少个lock就有多少个unlock
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                // state是volatile修饰的, 直接set的操作是原子的
                setState(nextc);
                return true;
            }
            return false;
        }
		// 尝试释放锁
        protected final boolean tryRelease(int releases) {
        	// 因为可重入的原因, state可能大于1, 所以对他进行减操作
        	// 这里为什么不用cas, 是因为操作锁的线程就只有这一个, 释放锁可以说是一个单线程的状态
            int c = getState() - releases;
            // 这里会进行该锁的线程判断
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            // c为0说明锁可以被释放
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
		// 判断持有锁的线程是不是当前线程的方法
        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
		
        final ConditionObject newCondition() {
            return new ConditionObject();
        }
		
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes the instance from a stream (that is, deserializes it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

具体实现类

	static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        // 非公平锁的.lock()方法最终调用的就是这个lock()
        final void lock() {
        	// 这里直接尝试去抢占, 而不是通过队列等待获取
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1); // 抢占失败才去调用acquire方法
        }
		// 这个nonfairTryAcquire就在父类Sync中
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
		// 公平锁, 调用AQS中的acquire方法排队获取
        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            // 与非公平锁的区别, 公平锁获取锁的过程一定是有序的
            if (c == 0) {
            	// AQS队列中没有前驱结点
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

AQS中的hasQueuedPredecessors方法, 判断是否有前驱结点

    public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        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());
    }

这里面h!=t还要判断h.next==null, 我的理解是, h!=t判断的是该结点有无被初始化以及是否只有一个头结点, 而为什么还要判断h.next是不是为null, 因为在并发的情况下, 初始化头结点的时候

			if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            }

在这里, cas设置了头结点, 此时tail = null, head = new node, head.next = null, 所以在这种情况下, 如果单纯是靠h != t来判断就会将这种情况也视为有前驱结点, 显然这个判断是错误的
这里必须要先判断h是否被初始化过, 否则null的.next会抛出异常

至于s.thread != Thread.currentThread()这一句的判断, 我的理解是此时h!=t, s也不为空, 线程b还是在head.next, 说明线程b是下一个要被唤醒的, 所以这里会返回false, 而上文中对hasQueuedPredecessors进行的非判断所以就会尝试去获取锁

构造器

无参构造器默认构造的是非公平锁
有参构造器根据传入的参数来设置公平与否

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

lock与unlock

都是用的sync方法, 其实ReentrantLock的大部分方法都是直接在sync内部类实现的

    public void lock() {
        sync.lock();
    }
	public void unlock() {
        sync.release(1);
    }

toString

使用toString方法出来的结果
java.util.concurrent.locks.ReentrantLock@6b884d57[Locked by thread main]
可以看出这个super的是object中的toString方法

    public String toString() {
    	// 获取占有这个锁的线程
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ?
                                   "[Unlocked]" :
                                   "[Locked by thread " + o.getName() + "]");
    }

后记

到此为止, 关于可重入锁的源码学习也告一段落了, 写并发操作的时候, 主要思考的是这一步操作中, 如果同时有另一个线程在进行另一个操作会不会对这一步操作有影响, 如果有那么说明这个并发操作是不成功的