AQS源码解析

Bertha 。 2023-02-17 01:18 70阅读 0赞

### 简介 ###

AQS的全称是AbstractQueuedSynchronizer,又叫队列同步器，
    	是用来构建锁或者其他同步组件的基础框架。
    	AQS使用int成员变量表示同步状态，通过内置的FIFO队列
    	来完成资源获取，线程排队的工作。

### 继承体系 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70]

其父类AbstractOwnableSynchronizer重要的源码如下

private transient Thread exclusiveOwnerThread;
    
    protected final void setExclusiveOwnerThread(Thread thread) { 
        exclusiveOwnerThread = thread;
    }
    
    
    protected final Thread getExclusiveOwnerThread() { 
        return exclusiveOwnerThread;
    }

只有一个属性，并提供了get/set方法

### 主要内部类 ###

static final class Node { 
        // 标识一个节点是共享模式
        static final Node SHARED = new Node();
        // 标识一个节点是互斥模式
        static final Node EXCLUSIVE = null;
       
        // 标识线程已取消
        static final int CANCELLED =  1;
        // 标识后继节点需要唤醒
        static final int SIGNAL    = -1;
        // 标识线程等待在一个条件上
        static final int CONDITION = -2;
        //标识后面的共享锁需要无条件的传播（共享锁需要连续唤醒读的线程）
        static final int PROPAGATE = -3;
        
     	// 当前节点保存的线程对应的等待状态
        volatile int waitStatus;
    	//前一个节点
        volatile Node prev;
    	//后一个节点
        volatile Node next;
    	//当前节点对应的线程
        volatile Thread thread;
        
        // 下一个等待在条件上的节点（Condition锁时使用）
        Node nextWaiter;
    
        //是否是共享模式
        final boolean isShared() { 
            return nextWaiter == SHARED;
        }
    
        //获取前一个节点
        final Node predecessor() { 
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
    
        //节点无参构造
         Node() {     // Used to establish initial head or SHARED marker
         }
    
        Node(Thread thread, Node mode) {      // Used by addWaiter
            // 把共享模式还是互斥模式存储到nextWaiter这个字段里面了
            this.nextWaiter = mode;
            this.thread = thread;
        }
    
        Node(Thread thread, int waitStatus) {  // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }

典型的双链表结构，节点中保存着当前线程、前一个节点、后一个节点以及线程的状态等信息。

### 主要属性 ###

// 队列的头节点
    private transient volatile Node head;
    private transient volatile Node tail;
    
    /** * The synchronization state. */
    private volatile int state;

定义了一个状态变量和一个队列，状态变量用来控制加锁解锁，队列用来放置等待的线程。

头尾节点和同步状态用volatile修饰保证其写操作对其他线程的可见性。

// 获取Unsafe类的实例
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //各种属性的偏移量，用于CAS
    private static final long stateOffset;
    private static final long headOffset;
    private static final long tailOffset;
    private static final long waitStatusOffset;
    private static final long nextOffset;
    
    static { 
        try { 
            //初始化各种属性的偏移量
            stateOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
            headOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
            tailOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
            waitStatusOffset = unsafe.objectFieldOffset
                (Node.class.getDeclaredField("waitStatus"));
            nextOffset = unsafe.objectFieldOffset
                (Node.class.getDeclaredField("next"));
    
        } catch (Exception ex) {  throw new Error(ex); }
    }
    
    /** * CAS head field. Used only by enq. */
    // 调用Unsafe的方法原子更新head
    private final boolean compareAndSetHead(Node update) { 
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }
    
    /** * CAS tail field. Used only by enq. */
    private final boolean compareAndSetTail(Node expect, Node update) { 
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }
    
    /** * CAS waitStatus field of a node. */
    private static final boolean compareAndSetWaitStatus(Node node,
                                                         int expect,
                                                         int update) { 
        return unsafe.compareAndSwapInt(node, waitStatusOffset,
                                        expect, update);
    }
    
    /** * CAS next field of a node. */
    private static final boolean compareAndSetNext(Node node,
                                                   Node expect,
                                                   Node update) { 
        return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
    }

### 子类需要重写的方法 ###

// 互斥模式下使用：尝试获取锁
    protected boolean tryAcquire(int arg) { 
        throw new UnsupportedOperationException();
    }
    // 互斥模式下使用：尝试释放锁
    protected boolean tryRelease(int arg) { 
        throw new UnsupportedOperationException();
    }
    // 共享模式下使用：尝试获取锁
    protected int tryAcquireShared(int arg) { 
        throw new UnsupportedOperationException();
    }
    // 共享模式下使用：尝试释放锁
    protected boolean tryReleaseShared(int arg) { 
        throw new UnsupportedOperationException();
    }
    // 如果当前线程独占着锁，返回true
    protected boolean isHeldExclusively() { 
        throw new UnsupportedOperationException();
    }

源码中给出的一个示例如何自定义Lock

class Mutex implements Lock, java.io.Serializable { 
    
        // Our internal helper class
        private static class Sync extends AbstractQueuedSynchronizer { 
            // Reports whether in locked state
            protected boolean isHeldExclusively() { 
                return getState() == 1;
            }
    
            // Acquires the lock if state is zero
            public boolean tryAcquire(int acquires) { 
                assert acquires == 1; // Otherwise unused
                if (compareAndSetState(0, 1)) { 
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
                return false;
            }
    
            // Releases the lock by setting state to zero
            protected boolean tryRelease(int releases) { 
                assert releases == 1; // Otherwise unused
                if (getState() == 0) throw new IllegalMonitorStateException();
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
    
            // Provides a Condition
            Condition newCondition() { 
                return new ConditionObject();
            }
    
            // Deserializes properly
            private void readObject(ObjectInputStream s)
                    throws IOException, ClassNotFoundException { 
                s.defaultReadObject();
                setState(0); // reset to unlocked state
            }
        }
    
        // The sync object does all the hard work. We just forward to it.
        private final Sync sync = new Sync();
    
        public void lock() { 
            sync.acquire(1);
        }
    
        public boolean tryLock() { 
            return sync.tryAcquire(1);
        }
    
        public void unlock() { 
            sync.release(1);
        }
    
        public Condition newCondition() { 
            return sync.newCondition();
        }
    
        public boolean isLocked() { 
            return sync.isHeldExclusively();
        }
    
        public boolean hasQueuedThreads() { 
            return sync.hasQueuedThreads();
        }
    
        public void lockInterruptibly() throws InterruptedException { 
            sync.acquireInterruptibly(1);
        }
    
        public boolean tryLock(long timeout, TimeUnit unit)
                throws InterruptedException { 
            return sync.tryAcquireNanos(1, unit.toNanos(timeout));
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200610155345167.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c=,size_16,color_FFFFFF,t_70