Was ist eine unfaire Sperre in Java?

1. Eine unfaire Sperre kann nicht garantieren, dass die Sperre in der Reihenfolge erworben wird, in der die Sperre angefordert wird. Dies kann dazu führen, dass ein oder mehrere Threads die Sperre nie erhalten.

2. Die Kosten für das Aufwecken von Threads durch die CPU können reduziert werden und die Gesamtdurchsatzeffizienz wird sehr hoch sein. Allerdings kann es Threads geben, die die Sperre über einen längeren Zeitraum oder sogar nie erhalten können, was zu einer Blockade führt.

Instanzen

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

Das obige ist der detaillierte Inhalt vonWas ist eine unfaire Sperre in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!