快捷導(dǎo)航

java非公平鎖知識點實例詳解

更新時間：2021年10月21日 08:33:15 作者：小妮淺淺

在本篇文章里小編給大家整理了一篇關(guān)于java非公平鎖知識點實例詳解，有興趣的朋友們可以學(xué)習(xí)參考下。

1、非公平鎖不能保證鎖的獲取是按照請求鎖的順序進行的。這可能會導(dǎo)致某個或某些線程永遠得不到鎖。

2、CPU喚醒線程的費用可以降低，整體吞吐效率會很高。但是可能會有線程長時間甚至永遠得不到鎖，導(dǎo)致餓死。

實例

 /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
 
        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
 
        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;
 
        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;
        }
    }

知識點擴展：

非公平鎖，顧名思義，各個線程獲取到鎖的順序，不一定和它們申請的先后順序一致，有可能后來的線程，反而先獲取到了鎖。

在實現(xiàn)上，公平鎖在進行l(wèi)ock時，首先會進行tryAcquire()操作。在tryAcquire中，會判斷等待隊列中是否已經(jīng)有別的線程在等待了。如果隊列中已經(jīng)有別的線程了，則tryAcquire失敗，則將自己加入隊列。如果隊列中沒有別的線程，則進行獲取鎖的操作。

/**
     * 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;
    }

非公平鎖，在進行l(wèi)ock時，會直接嘗試進行加鎖，如果成功，則獲取到鎖，如果失敗，則進行和公平鎖相同的動作。

到此這篇關(guān)于java非公平鎖知識點實例詳解的文章就介紹到這了,更多相關(guān)java非公平鎖如何理解內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: