【Java 并发编程实战】使用 AQS 实现一个简单的互斥锁

    /**
     * Returns a collection containing threads that may be waiting to
     * acquire.  Because the actual set of threads may change
     * dynamically while constructing this result, the returned
     * collection is only a best-effort estimate.  The elements of the
     * returned collection are in no particular order.  This method is
     * designed to facilitate construction of subclasses that provide
     * more extensive monitoring facilities.
     *
     * @return the collection of threads
     */
    public final Collection<Thread> getQueuedThreads() {
        ArrayList<Thread> list = new ArrayList<Thread>();
        for (Node p = tail; p != null; p = p.prev) {
            Thread t = p.thread;
            if (t != null)
                list.add(t);
        }
        return list;
    }


    /**
     * Returns a collection containing threads that may be waiting to
     * acquire in exclusive mode. This has the same properties
     * as {@link #getQueuedThreads} except that it only returns
     * those threads waiting due to an exclusive(独有的；排外的；专一的) acquire.
     *
     * @return the collection of threads
     */
    public final Collection<Thread> getExclusiveQueuedThreads() {
        ArrayList<Thread> list = new ArrayList<Thread>();
        for (Node p = tail; p != null; p = p.prev) {
            if (!p.isShared()) {
                Thread t = p.thread;
                if (t != null)
                    list.add(t);
            }
        }
        return list;
    }

if V==A (Compare)
then V=B (Swap)

   /**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }



    // Queuing utilities

    /**
     * The number of nanoseconds for which it is faster to spin
     * rather than to use timed park. A rough estimate suffices
     * to improve responsiveness with very short timeouts.
     */
    static final long spinForTimeoutThreshold = 1000L;

    /**
     * Inserts node into queue, initializing if necessary. See picture above.
     * @param node the node to insert
     * @return node's predecessor
     */
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

package com.light.sword

import java.util.concurrent.locks.AbstractQueuedSynchronizer

/**
 * @author: Jack
 * 2020-02-10 15:42
 * 使用 AQS 实现一个简单的互斥锁
 */

class MutexDemo {
    private val sync = Sync()
    fun lock() {
        sync.acquire(0)
    }

    fun unlock() {
        sync.release(0)
    }

    class Sync : AbstractQueuedSynchronizer() {
        private val LOCKED = 1
        private val UNLOCKED = 0

        init {
            state = UNLOCKED
        }

        override fun tryAcquire(arg: Int): Boolean {
            return compareAndSetState(UNLOCKED, LOCKED)
        }

        override fun tryRelease(arg: Int): Boolean {
            state = UNLOCKED
            return true
        }
    }

}

fun main() {
    for (i in 0..10) {
        Thread {
            task(Thread.currentThread().name)
        }.start()
    }

    val mutex = MutexDemo()
    for (i in 0..10) {
        Thread {
            mutex.lock()
            task(Thread.currentThread().name)
            mutex.unlock()
        }.start()
    }
}

fun task(threadName: String) {
    println("-------------")
    println("${System.currentTimeMillis()} : $threadName")
    Thread.sleep(1000)
}


// 输出：
-------------
-------------
1581489100026 : Thread-1
-------------
-------------
1581489100026 : Thread-2
-------------
1581489100026 : Thread-5
-------------
1581489100026 : Thread-0
-------------
1581489100026 : Thread-6
-------------
1581489100027 : Thread-10
-------------
-------------
1581489100027 : Thread-9
1581489100026 : Thread-4
-------------
1581489100027 : Thread-3
1581489100026 : Thread-8
1581489100027 : Thread-7
-------------
1581489100027 : Thread-11
-------------
1581489101028 : Thread-12
-------------
1581489102029 : Thread-13
-------------
1581489103030 : Thread-14
-------------
1581489104031 : Thread-15
-------------
1581489105032 : Thread-16
-------------
1581489106034 : Thread-17
-------------
1581489107036 : Thread-18
-------------
1581489108039 : Thread-19
-------------
1581489109042 : Thread-20
-------------
1581489110046 : Thread-21