Java 公平锁与非公平锁学习研究

最近学习研究了一下Java中关于公平锁与非公平锁的底层实现原理,总结了一下.

首先呢,通过其字面意思,公平与非公平的评判标准就是付出与收获成正比(和社会中的含义差不多一个意思).放到程序中,尤其是

在多线程环境,线程获取资源(CPU\内存\网络等等)的时序与其所再此资源上消耗的等待时间成正比,亦即我等的时间越长,获取

该资源的时序越短.(和上学时排队打饭一个道理).公平锁这个样子,那非公平锁,简单来说也就是插队.(不过,Java实现还是有些差别的,

稍后会重点说明)

Java中关于公平锁与非公平锁的实现,是基于AQS(AbstractQueuedSynchronizer)实现的,想要深入研究Java锁及同步技术,该类是

绕不过去,So,Let's fuck up this bitch!

从名字上来简单翻译一下,抽象排队同步器(绕口.....),顾名思义,就是为实现排队获取资源同步抽象类,按照其官方说明,一些比较重要的同步

工具类(Semaphore信号量,CountDownLatch闭锁,CyclicBarrier栅栏等)等底层都是由该类完成其核心功能实现的,是对资源同步抽象.

该抽象类主要的核心:排队\同步(从其名字上就可以看出),先来分析一下其排队实现

• 排队:该类是基于一种双向不循环列表来实现其队列功能的,大致数据结构如下草图,

  

  再通过将线程与必要的状态值进行封装成节点,再利用其同步原理来实现.

• 同步:基于sun.misc.Unsafe来实现CAS原子性操作(Compare and Swap)

/**
     * CAS head field. Used only by enq.
     */
    private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }

    /**
     * CAS tail field. Used only by enq.
     */
    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

    /**
     * CAS waitStatus field of a node.
     */
    private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) {
        return unsafe.compareAndSwapInt(node, waitStatusOffset, expect, update);
    }

    /**
     * CAS next field of a node.
     */
    private static final boolean compareAndSetNext(Node node, Node expect, Node update) {
        return unsafe.compareAndSwapObject(node, nextOffset, expect, update);  }

基于以上两个核心点,完成大多说同步操作.接下来,再看一下公平锁与非公平锁实现原理,废话不多说,直接上码:

/**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the 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();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                // overflow
                if (nextc < 0) {
                    throw new Error("Maximum lock count exceeded");
                }
                setState(nextc);
                return true;
            }
            return false;
        }

        @Override
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        @Override
        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();
        }

        // Methods relayed from outer class

        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();
            // reset to unlocked state
            setState(0);
        }
    }

    /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends ReentrantLock.Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        @Override
        final void lock() {
            // CAS原子性操作
            if (compareAndSetState(0, 1)) {
                // 设置独占所有线程线程
                setExclusiveOwnerThread(Thread.currentThread());
            } else {
                acquire(1);
            }
        }

        @Override
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends ReentrantLock.Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        @Override
        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        @Override
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
        }
    }

这个就是Java中大名鼎鼎的公平锁与非公平锁的实现,两者最主要的区别在于其获取锁的方式,非公平锁获取时:

而公平锁:

最主要的区别就在于红线圈起来的地方.还有一点需要特别说明的地方就是公平锁与非公平锁的行为区别主要在获取锁时,如果

两种形式锁都未获取成功的话就会乖乖去排队等待锁被释放,此时两种锁的行为是一致的,都是FIFO,先进先出规则,绝对公平,一朝

入队,绝对公平呦!!!

举个很不雅但很贴切的例子,排队上厕所.公平锁就是,你内急了,就去乖乖的排队,到时候自然会轮到你.而非公平锁就是你内急了,

就可以尝试一下去进入厕所间并锁门,如果恰好成功的话,就捷足先登喽;不行的话就去排队.而且在获取锁时也不用考虑排在队列

前面的人,直接就可以尝试去占有厕所,成功了就万事大吉.