并发编程--公平锁和非公平锁

超、凢脫俗 2022-06-16 21:27 224阅读 0赞

在上一篇博客[并发编程--互斥锁ReentrantLock][--_ReentrantLock]中我们简单介绍了一下ReentrantLock，ReentrantLock提供了公平锁和非公平锁的机制，我们已经了解到ReentrantLock提供了一个FIFO线程队列，对于公平锁来说，当锁是可获取时首先让FIFO队列中的线程获取锁，当前线程需要进FIFO队列进行等待；对于非公平锁来说，当锁是可获取时，这个线程可以直接获取锁，不用在FIFO中排队等待。

公平锁实现：

获取锁

final void lock() {
                acquire(1);//设置state为1
            }

//tryAcquire(arg) 尝试获取锁
    //acquireQueued(addWaiter(Node.EXCLUSIVE), arg)尝试获取锁失败后将线程放到FIFO队列中
    public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
    			//c=0时此时锁可获取
                if (c == 0) {
    				//首先判断hasQueuedPredecessors()队列首的线程是否是当前线程，不是则不作操作最后返回false
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
    			//即使c不等于0，需要判断当前获取锁的线程是否是当前线程
                else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
        }

以上代码的实现机制：当前线程是否是FIFO队列的第一个线程，如果不是当前线程则进FIFO队列，实现了公平锁，如果当前线程是FIFO队列中的第一个线程则获取锁并运行。

非公平锁：

final void lock() {
    	//如果当前锁是可获取的，则当前线程直接获取锁不用进FIFO排队获取锁
    	if (compareAndSetState(0, 1))
    		setExclusiveOwnerThread(Thread.currentThread());
    	else
    		//不然，排队获取锁
    		acquire(1);
    	}

以上代码的实现机制：如果当前锁是可获取的则直接获取锁，不用排队，不然则需要进FIFO队列排队获取锁。

简单来说Reentrant的实现就是依靠公平锁和非公平锁实现的。

非公平锁源码：

//非公平锁
        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);
            }
        }

公平锁源码：

//公平锁
        static final class FairSync extends Sync {
            private static final long serialVersionUID = -3000897897090466540L;
    
            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) {
                    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;
            }
        }

公平锁和非公平锁的父类是同步锁Sync，源码如下，其实FIFO和volatile变量都是在AbstractQueuedSynchronizer中实现的，AbstractQueuedSynchronizer是同步包中实现锁机制最重要的类。

abstract static class Sync extends AbstractQueuedSynchronizer {
            private static final long serialVersionUID = -5179523762034025860L;
    
            
            abstract void lock();
    
            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;
            }
    
            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;
            }
    
            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();
                setState(0); // reset to unlocked state
            }
        }

[--_ReentrantLock]: http://blog.csdn.net/qq924862077/article/details/69551220