正文

揭秘AQS锁源码：深度解析Java并发核心机制

/0 浏览量
0329

引言

在Java并发编程中，锁是保证线程安全的重要机制。AbstractQueuedSynchronizer（AQS）是Java并发包中一个核心的同步器，它提供了一种构建锁和其他同步组件的基础。本文将深入解析AQS的源码，帮助读者理解Java并发核心机制。

AQS概述

AQS是Java并发包中的一个抽象类，它提供了锁、信号量、屏障等同步组件的基础。AQS的核心思想是使用一个共享资源（state）来表示锁的状态，并通过一个队列来管理等待获取锁的线程。

AQS的内部结构

AQS内部包含以下几个关键组件：

  • state：表示锁的状态，通过volatile关键字保证多线程间的可见性。
  • CLH队列：一个双向链表，用于存储等待获取锁的线程。
  • acquire：尝试获取锁的方法，如果锁不可用，则将当前线程加入队列。
  • release：释放锁的方法，将共享资源state设置为0，并唤醒队列中的第一个线程。
  • tryAcquire：尝试获取锁的方法，如果成功则返回true，否则返回false。

AQS的锁实现

AQS提供了两种锁的实现：独占锁和共享锁。

独占锁

独占锁是指一次只有一个线程可以获取锁。ReentrantLock是AQS的独占锁实现。

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;

    public ReentrantLock() {
        this.sync = new NonfairSync();
    }

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

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

    // ... 其他方法 ...
}

abstract static class Sync extends AbstractQueuedSynchronizer {
    // ... 省略 ...
}

static final class NonfairSync extends Sync {
    // ... 省略 ...
}

static final class FairSync extends Sync {
    // ... 省略 ...
}

共享锁

共享锁是指多个线程可以同时获取锁。ReentrantReadWriteLock是AQS的共享锁实现。

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    private final ReadLock readLock;
    private final WriteLock writeLock;

    public ReentrantReadWriteLock() {
        this.readLock = new ReentrantReadWriteLock.ReadLock(this);
        this.writeLock = new ReentrantReadWriteLock.WriteLock(this);
    }

    public ReadLock readLock() {
        return readLock;
    }

    public WriteLock writeLock() {
        return writeLock;
    }

    // ... 其他方法 ...
}

static final class ReadLock implements Lock, java.io.Serializable {
    private final ReentrantReadWriteLock lock;

    public ReadLock(ReentrantReadWriteLock lock) {
        this.lock = lock;
    }

    public void lock() {
        lock.acquireShared(1);
    }

    public void unlock() {
        lock.releaseShared(1);
    }

    // ... 其他方法 ...
}

static final class WriteLock implements Lock, java.io.Serializable {
    private final ReentrantReadWriteLock lock;

    public WriteLock(ReentrantReadWriteLock lock) {
        this.lock = lock;
    }

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

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

    // ... 其他方法 ...
}

AQS的源码解析

以下是对AQS源码的简要解析：

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
    // ... 省略 ...

    protected final int tryAcquireShared(int acquires) {
        return -1;
    }

    protected final boolean tryReleaseShared() {
        return false;
    }

    public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

    private Node addWaiter(Node mode) {
        Node node = new Node(mode);
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            pred.next = node;
            tail = node;
        } else {
            head = tail = node;
        }
        return node;
    }

    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0) {
            node.waitStatus = 0;
        }
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node p = tail; p != null; p = p.prev) {
                if ((s = p.next) == null || s.waitStatus <= 0) {
                    break;
                }
            }
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

    // ... 省略 ...
}

总结

本文深入解析了AQS的源码，帮助读者理解Java并发核心机制。通过AQS，我们可以构建出高效的锁和同步组件，从而提高程序的并发性能。希望本文对您有所帮助。

-- 展开阅读全文 --