并发编程[4]—AQS【并发的半壁江山】

一、AbstractQueuedSynchronizer深入分析

1.1 AQS使用方式和其中的设计模式

继承，模板方法设计模式
其中的方法
模板方法：
独占式获取
accquire
acquireInterruptibly
tryAcquireNanos
共享式获取
acquireShared
acquireSharedInterruptibly
tryAcquireSharedNanos
独占式释放锁
release
共享式释放锁
releaseShared

需要子类覆盖的流程方法
独占式获取 tryAcquire
独占式释放 tryRelease
共享式获取 tryAcquireShared
共享式释放 tryReleaseShared
这个同步器是否处于独占模式 isHeldExclusively

同步状态state：
getState:获取当前的同步状态
setState：设置当前同步状态
compareAndSetState 使用CAS设置状态，保证状态设置的原子性

AQS中使用的模板方法设计模式

package com.AQS;

import java.util.Date;

/**
 * 模板方法模式
 * 在父类中定义抽象方法，然后再定义一个模板（框架）方法
 */
public abstract class SendCustom {
    public abstract void to();

    public abstract void from();

    public abstract void content();

    public void date() {
        System.out.println(new Date());
    }

    public abstract void send();

    // 框架方法
    public void sendMessage() {
        to();
        from();
        content();
        date();
        send();
    }
}

package com.AQS;

public class SendSms extends SendCustom {
    @Override
    public void to() {
        System.out.println("发送给A");
    }

    @Override
    public void from() {
        System.out.println("B发送信息");
    }

    @Override
    public void content() {
        System.out.println("hello world");
    }

    @Override
    public void send() {
        System.out.println("send SMS");
    }

    public static void main(String[] args) {
        SendCustom sendSms = new SendSms();
        sendSms.sendMessage();
    }
}

自己实现类似ReentrantLock（独占锁）

package com.AQS;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 实现自己的类似ReentrantLock(独占锁)
 */
public class SelfLock implements Lock {
    //state 表示获取到锁 state=1 获取到了锁，state=0，表示这个锁当前没有线程拿到
    private static class Sync extends AbstractQueuedSynchronizer {
        //是否占用
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        protected boolean tryRelease(int arg) {
            if (getState() == 0) {
                throw new UnsupportedOperationException();
            }
            setExclusiveOwnerThread(null);
            // 释放锁为什么没有采用原子操作，因为锁只能有一个线程持有，没有其他线程抢着释放锁
            setState(0);
            return true;
        }

        Condition newCondition() {
            return new ConditionObject();
        }
    }

    private final Sync sycn = new Sync();

    @Override
    public void lock() {
        sycn.acquire(1);

    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sycn.acquireInterruptibly(1);

    }

    @Override
    public boolean tryLock() {
        return sycn.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sycn.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        sycn.release(1);

    }

    @Override
    public Condition newCondition() {
        return sycn.newCondition();
    }
}

package com.AQS;

import java.util.concurrent.locks.Lock;

public class SelfLockTest {
    public void test() throws InterruptedException {
        final Lock selfLock = new SelfLock();
        class Worker extends Thread {
            public void run() {
                while (true) {
                    selfLock.lock();
                    try {
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName());
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        selfLock.unlock();
                    }
                }
            }
        }
        // 启动10个子线程
        for (int i = 0; i < 5; i++) {
            Worker w = new Worker();
            w.setDaemon(true);
            w.start();
        }
        // 主线程每隔1秒换行
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SelfLockTest selfLockTest = new SelfLockTest();
        selfLockTest.test();
    }
}

二、AQS的原理

AQS采用的数据结构-节点和同步队列（先进先出，双向链表）
简单描述：首先同步器有两个指针，一个指向首节点，另外一个指向尾结点。以独占式锁为例，当线程A请求锁时，线程B刚好也请求锁，此时锁被线程A占用着，那就将线程B打包为一个node节点，添加到同步队列，此时线程C也请求锁，发现A还在占用锁，队列中已经有B线程在等待了，然后线程C也会被打包放在线程B的后面。

同步器设置首节点时不需要采用CAS操作，但是设置尾结点是需要采用CAS操作，同步队列里面的线程在等待锁的过程中采用的自旋方式。
java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire（获取锁）
方法tryAcquire(arg)如果拿到锁，就返回true,如果没有拿到锁返回false，然后将使用方法addWaiter(Node.EXCLUSIVE)该线程打包成Node节点，通过acquireQueued(addWaiter(Node.EXCLUSIVE), arg))添加到队列，后续其他代码咨询查看源码。

节点加入到同步队列

首节点的变化

独占式同步状态获取与释放

三、共享式同步状态获取与释放

package com.AQS;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;

/**
 * 三元共享同步工具类
 */
public class TrinityLock   {

    //为3表示允许两个线程同时获得锁
    private final Sync sync = new Sync(3);

    private static final class Sync extends AbstractQueuedSynchronizer {
        //private static final long serialVersionUID = -7889272986162341211L;

        Sync(int count) {
            if (count <= 0) {
                throw new IllegalArgumentException("count must large than zero.");
            }
            setState(count);
        }

        public int tryAcquireShared(int reduceCount) {
            // 采用自旋 加上 CAS
            for (;;) {
                int current = getState();
                int newCount = current - reduceCount;
                if (newCount < 0 || compareAndSetState(current, newCount)) {
                    return newCount;
                }
            }
        }

        public boolean tryReleaseShared(int returnCount) {
            for (;;) {
                int current = getState();
                int newCount = current + returnCount;
                if (compareAndSetState(current, newCount)) {
                    return true;
                }
            }
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }
    }

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

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

    public void lockInterruptibly() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    public boolean tryLock() {
        return sync.tryAcquireShared(1) >= 0;
    }

    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(time));
    }

    public Condition newCondition() {
        return sync.newCondition();
    }
}

三、Condition分析

一个锁可以有多个Condition

同步队列与等待队列

节点在队列之间的移动
await()

signal()

待补充：await(),signal()方法的区别