Apakah prinsip pelaksanaan Java AQS

Gunakan

Di sini kami menggunakan ReentrantLock untuk memahami prinsip pelaksanaan AQS.

kunci

Kaedah ini adalah titik masuk untuk mula memperoleh operasi kunci Dalam pelaksanaan kaedah ini, objek sync diserahkan untuk memperoleh kunci.

public void lock() {
    sync.acquire(1);
}

private final Sync sync;
// Sync对象是一个ReentrantLock实现的内部抽象类，具体的实现又分为了公平版本与非公平两种
abstract static class Sync extends AbstractQueuedSynchronizer {}

// 在ReentrantLock的无参构造器中，默认使用的实现就是非公平锁的实现
public ReentrantLock() {
    sync = new NonfairSync();
}

// 也可以通过带参数的构造器来使用公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

Segerak

Memandangkan perbezaan antara kunci saksamaFairSync dan NonfairSync terutamanya dalam kaedah tryAcquire, logik lain adalah sama, jadi kita akan melihat terus pada SyncDan pelaksanaan dalam AQS. Kaedah

acquire

dilaksanakan seperti berikut, daripada pelaksanaan AQS: Kaedah

// 首先会调用 tryAcquire 和 acquireQueued 方法，如果2个方法都返回true的话，
// 那么才会调用自行中断的逻辑
if (!tryAcquire(arg) &&
    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();

tryAcquire Terdapat dua jenis kerana perbezaan antara kunci adil dan kunci tidak adil Pelaksanaan yang berbeza, mari kita lihat dahulu pelaksanaan kunci tidak adil, yang merupakan strategi lalai ReentrantLock.

NonfairSync.tryAcquire

Kaedah ini akan terus memanggil dan mengembalikan kaedah Sync yang dilaksanakan oleh nonfairTryAcquire(acquires).

Pelaksanaan dalam kelas Penyegerakan

// 这里的参数 acquires = 1
final boolean nonfairTryAcquire(int acquires) {
    // 获取当前调用者的线程对象
    final Thread current = Thread.currentThread();
    // 获取AQS中定义的state值，这个state值是AQS的核心之一
    int c = getState();
    // 在ReentrantLock的实现中，state就表示当前是否有线程持有锁，0代表没有线程持有锁，
    // 当前访问的线程就可以继续执行代码，如果大于0则表示当前持有锁的线程的数量。
    // 由于ReentrantLock属于可重入锁，因此，这个值会>=1
    if (c == 0) {
        // 能进来就表示当前没有线程持有锁，那么尝试用CAS获取锁
        if (compareAndSetState(0, acquires)) {
            // 获取锁成功，那么将当前线程设置到AQS中的当前线程中
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果当前持有锁的就是自己，那么就代表是锁的重入
    else if (current == getExclusiveOwnerThread()) {
        // 累计持有锁的次数
        int nextc = c + acquires;
        // 这里就说明了，state能够设置的最大值就是Int.MAX_VALUE，
        // 当处于MAX_VALUE的时候再加1，那么Int数字的最高位就会变成1，符号位为负
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新新的state值
        setState(nextc);
        return true;
    }
    return false;
}

Pelaksanaan dalam AQS

private volatile int state;
// 当前持有锁的线程对象
private transient Thread exclusiveOwnerThread;

protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

Untuk meringkaskan, tidak adil Kunci tryAcquire kaedah adalah untuk melihat dahulu jika terdapat benang yang memegang kunci Jika tidak, cuba dapatkan kunci melalui CAS Jika kunci berjaya diperoleh atau anda masuk semula, maka kaedah tryAcquire akan kembali benar, <.>Penghakiman bersyarat dalam kaedah akan secara langsung mengembalikan palsu, kaedah kunci tamat dan benang terus menyokong kod berikut. acquire

FairSync.tryAcquire

Mari kita lihat pelaksanaan kunci adil Logik umum adalah sama seperti kunci tidak adil.

Pelaksanaan dalam FairSync

// 这里的参数 acquire = 1
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // 判断当前是不是有线程持有锁
    if (c == 0) {
        // 当前没有线程持有锁就进来
        // 由于是公平锁，那么就要保证只有在当前等待队列为空或者队列中等待的线程
        // 都没有到运行的条件的时候，才尝试通过CAS来获取锁。否则就去乖乖排队
        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;
}

Pelaksanaan dalam AQS

// 检查当前AQS等待队列中是否有正在等待的有效线程节点
public final boolean hasQueuedPredecessors() {
    Node h, s;
    // 首先让参数h指向当前队列的头部
    if ((h = head) != null) {
        // 队列不为空
        // 将临时变量赋值为当前第二个节点
        // 这里需要简单说明一下AQS的等待队列的构成，第一个节点是没有业务含义的，
        // 只是用作唤醒下一个待执行的线程节点
        if ((s = h.next) == null || s.waitStatus > 0) {
            // 能进来就表示当前队列只有一个头结点，或者第二个节点的状态是已取消
            // - > 参考说明1
            // 如果第二个节点不为空，那么就释放这个引用
            s = null; // traverse in case of concurrent cancellation
            // 从后往前遍历，找到距离队列头最近的有效节点
            for (Node p = tail; p != h && p != null; p = p.prev) {
                if (p.waitStatus <= 0)
                    s = p;
            }
        }
        // 如果找到了正在队列中的排队的有效节点并且不是当前访问的线程，那么就返回true
        if (s != null && s.thread != Thread.currentThread())
            return true;
    }
    // 头结点指向NULL，那么说明队列是空的，直接返回false
    return false;
}

Nota 1: Ia diperkenalkan di sini Faham konsep penting keadaan menunggu dalam nod baris gilir Dalam

, kita hanya perlu memberi perhatian kepada ReentrantLock dan CANCELLED. Hanya SIGNAL lebih besar daripada 0, dan nilai lalai nod baharu ialah 0. Oleh itu, selagi status menunggu lebih besar daripada 0, ini bermakna nod telah dibatalkan. CANCELLED

// 等待队列中节点的等待状态
volatile int waitStatus;
// 当前节点因为等待超时或者被中断了被取消
static final int CANCELLED =  1;
// 接下来有资格被唤醒获得锁的标记，只有获得了这个标记的节点才能被执行完的线程唤醒
static final int SIGNAL    = -1;

Untuk meringkaskan, berbanding dengan kunci adil, apabila ada peluang untuk memperoleh kunci pada mulanya, ia akan terlebih dahulu menyemak sama ada sudah ada benang dalam baris gilir semasa menunggu pelaksanaan Jika ada benang menunggu dalam baris gilir, Kunci akan diperoleh hanya apabila baris gilir kosong atau tiada nod baris gilir yang sah. Jika kunci berjaya diperoleh atau kunci berjaya dimasukkan semula, logik AQS juga akan tamat dan kod perniagaan akan terus dilaksanakan.

acquireQueued

Selepas menganalisis situasi di atas, jika kunci berjaya diperoleh dalam kaedah

, logik AQS akan tamat Seterusnya, mari analisa logik kegagalan untuk memperoleh kunci, iaitu :tryAcquirePenghakiman bersyarat kedua bagi penghakiman bersyarat dalam kaedah. acquire

Dilaksanakan dalam AQS

// 这个方法就会将当前线程添加到等待队列中，并且返回操作是否成功，arg就是传入的acquire值，为1
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

Mula-mula bina nod yang mengandungi objek benang melalui kaedah

dan tambahkannya pada baris gilir addWaiter

// 这里的参数为 Node.EXCLUSIVE，表示这是一个排它锁的实现，这里的值为NULL
private Node addWaiter(Node mode) {
    // 构建一个线程节点
    Node node = new Node(mode);

    // 这里就是AQS的核心理念了，通过不断的自旋，将线程节点插入到队列中
    for (;;) {
        // 获取原来的队列的队尾，因为AQS才去的尾插方式
        Node oldTail = tail;
        if (oldTail != null) {
            // 将新插入的节点指向原来的尾结点
            node.setPrevRelaxed(oldTail);
            // 通过CAS的方式将当前节点设置到线程共享队列的尾部去，这里要注意，
            // 凡是涉及到多线程操作的属性，都需要通过CAS保证操作的原子性
            if (compareAndSetTail(oldTail, node)) {
                oldTail.next = node;
                // 设置成功，就返回插入的节点对象；如若不成功，
                // 就表示有别的线程也修改了尾结点，那么就要等下一次循环重试
                return node;
            }
        } else {
            // 没有尾结点说明队列不存在，那么就进行初始化
            initializeSyncQueue();
        }
    }
}

// 初始化等待队列
private final void initializeSyncQueue() {
    Node h;
    // 还是通过CAS的方式，给队列初始化一个默认的Node节点，几个重要的属性的初始值如下
    // waitStatus = 0; thread = null
    if (HEAD.compareAndSet(this, null, (h = new Node())))
        tail = h;
}

Untuk meringkaskan, kaedah

menggunakan sisipan ekor untuk membungkus benang yang belum mencengkam kunci ke dalam nod addWaiter dan memasukkannya ke dalam baris gilir menunggu AQS. Jika baris gilir belum dimulakan, mulakan baris gilir dahulu, dan baris gilir datang dengan nod kepala yang tidak mempunyai makna sebenar. Node

acquireQueued

Dilaksanakan dalam AQS

// arg就是传入的acquire参数，为1；该方法返回值的含义为，线程在等待过程中是否被中断
final boolean acquireQueued(final Node node, int arg) {
    boolean interrupted = false;
    try {
        // 还是不断的自旋，等待机会进行操作
        for (;;) {
            // 获取新插入节点的上一个节点
            final Node p = node.predecessor();
            // 如果上一个节点已经是头结点，那么说明当前就已经轮到当前线程获取锁执行业务了
            // 那么就再次尝试抢一次锁
            if (p == head && tryAcquire(arg)) {
                // 能进来就说明获取锁成功了
                // 那么就将当前线程的节点设置为头结点
                // 在这个方法中，会去除节点中的信息，做一个纯粹的头结点
                setHead(node);
                // 将已经没有指向的原头结点的next指为空，等待回收
                p.next = null; // help GC
                // 这里返回的值为false，因为当前线程并未被阻塞就获得了锁
                return interrupted;
            }
            // 走到这里说明当前线程并没有获取到锁，那么就要考虑是否要将线程阻塞了
            if (shouldParkAfterFailedAcquire(p, node))
                interrupted |= parkAndCheckInterrupt();
        }
    } catch (Throwable t) {
        cancelAcquire(node);
        if (interrupted)
            selfInterrupt();
        throw t;
    }
}

private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

// 线程获取锁失败之后，是否需要将线程阻塞，这里2个参数，
// pred是新插入节点的上一个节点，node是新插入的节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取上一个节点的等待状态
    int ws = pred.waitStatus;
    // 判断上一个节点的状态是不是SIGNAL，只有状态为SIGNAL的才是有效的可指向节点
    if (ws == Node.SIGNAL)
        // 如果上一个节点是SIGNAL状态，那就说明当前线程可以连接上该节点，然后被挂起了
        return true;
    // 上面我们提到过，只有节点被取消了，等待状态才会>0
    if (ws > 0) {
        // 一直往前找，直到找到等待状态<=0的，数据规范的话即找到最近的一个等待状态
        // 为SIGNAL的节点，跳过全部被取消的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 此时pred指向的即第一个合法的线程节点，指向当前新插入的节点
        pred.next = node;
    } else {
        // 这里的意思就是上一个节点就是有效节点，那么就将上一个节点的等待状态强制
        // 更新为SIGNAL，即-1。毫无意义的那个头结点也会被设置为SIGNAL状态
        pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
    }
    return false;
}

Untuk meringkaskan, maksud kaedah ini ialah memandangkan utas semasa belum memperoleh kunci sumber, Oleh itu ia perlu disekat. Pada masa yang sama, dalam kaedah ini, baris gilir menunggu juga akan diisih dan nod yang telah dibatalkan akan dialih keluar daripada baris gilir. Langkah seterusnya ialah memanggil kaedah pelaksanaan dalam penghakiman bersyarat untuk menggantung dan menyekat benang.

private final boolean parkAndCheckInterrupt() {
    // 调用了park方法，底层是调用UnSafe类的park方法来实现
    LockSupport.park(this);
    return Thread.interrupted();
}

Pada ketika ini, semua butiran kaedah

adalah jelas Jika benang boleh mendapatkan kunci, ia akan menamatkan fasa kunci secara langsung masukkan barisan menunggu Sebelum memasuki barisan, jika didapati masih ada peluang untuk memperoleh kunci, ia akan cuba untuk memperolehnya semula , dan sekat urutan dengan memanggil kaedah LockSupport.park, menunggu untuk dibangkitkan . lock

buka kunci

Selepas aktif memanggil kaedah ini, ini bermakna pendudukan kunci telah tamat.

dilaksanakan dalam ReentrantLock

public void unlock() {
    sync.release(1);
}

dilaksanakan dalam AQS

public final boolean release(int arg) {
    // 调用tryRelease方法真正实现解除锁
    // 只有state加的所有锁被解除了，那么才会唤醒下一个线程
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

dilaksanakan dalam Sync Implement

// 这里的releases就是传入的参数1，即如果是重入锁，那么这里需要解锁多次
protected final boolean tryRelease(int releases) {
    // 计算state的值，这里的含义就是state-1
    int c = getState() - releases;
    // 如果当前线程不是持有锁的线程，那么就报错
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 锁是否完全释放完的标记
    boolean free = false;
    // state减到0说明锁已经完全释放完了
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 更新state的值
    setState(c);
    // 只有锁被完全释放完，才返回true
    return free;
}

pelaksanaan

// 唤醒下一个需要锁的线程，这里的node是头结点
private void unparkSuccessor(Node node) {
    // 获得头结点的等待状态
    int ws = node.waitStatus;
    // 如果头结点是SIGNAL，那么重置为0，因为这个节点已经没有意义了，会被移除
    if (ws < 0)
        node.compareAndSetWaitStatus(ws, 0);
    // 获得头结点后面的待唤醒的节点
    Node s = node.next;
    // 如果这个待唤醒的节点为空或者等待状态不正确，在这里就是不等于SIGNAL
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从尾部开始查询，找到合法的待唤醒节点
        for (Node p = tail; p != node && p != null; p = p.prev)
            if (p.waitStatus <= 0)
                s = p;
    }
    if (s != null)
        // 唤醒线程
        LockSupport.unpark(s.thread);
}

membatalkanCquire

dalam AQS. kunci.

dilaksanakan dalam AQS

Atas ialah kandungan terperinci Apakah prinsip pelaksanaan Java AQS. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!