多线程6 - CAS和AQS的应用和原理

java 里有两种锁

• synchronized （jvm内部实现）
• lock （ jdk源码实现）

synchronized 在jdk6之前加锁方式是重量级锁，之后因为Lock锁的出现，synchronized进行了优化，才有的偏向锁/轻量级锁，两者性能差不多，但lock提供了一些比synchronized更高级的功能。  

那么Doug Lea是怎样写的同步锁呢？

我们先了解一些要用到的知识：

CAS：全称compare and swap（比较交换），比较三个值，内存里的值（O）、预期值（E）、新值（N），在进行CAS操作时，会比较O 和 E 是否相等，相等就把N的值赋值给O，可以理解为修改密码，数据库值（O），验证旧密码（E），新密码（N）验证通过，修改成功。

UNSAFE：给jdk提供最底层的方法，包括volatile、线程调度、CAS相关、内存相关等功能。

尝试写一个同步锁，可能的方式如下：

1.使用自旋

2.sleep+自旋

3.yield+自旋

4.park+自旋

下面使用了AtomicInteger类，他也是Doug lea写的，底层调用unsafe类实现，即借用它来实现。

第一种方案是自旋

让线程去加锁，加锁失败的就一直空转，它会一直消耗CPU资源  

public class SlipLock {
    // 0：无锁
    private volatile AtomicInteger status = new AtomicInteger(0);

    public void lock(){
        while (!status.compareAndSet(0, 1)) {
        }
    }

    public  void unlock(){
        status.set(0);
    }
}
           

public static void spinLockTest(){
    List<Thread> list = new ArrayList<>();
    SlipLock lock = new SlipLock();
    for (int i = 0; i < 10; i++) {
        Thread t1 = new Thread(()->{
            lock.lock();
            for (int j = 0; j < 10; j++) {
                System.out.print(Thread.currentThread().getName()+" "+j);
            }
            System.out.println();
            lock.unlock();
        },"线程-"+i);
        list.add(t1);
    }
    list.forEach(t->t.start());
}
           

第二种方案：yield+自旋

自旋锁让线程一直处于空转状态，并没有让出CPU，使用yield可以让出CPU，但是并不能保证下一次不是该线程。 而且yield方法只会给相同优先级或更高优先级的线程机会。  

public class YieldLock {
    // 0：无锁
    private AtomicInteger status = new AtomicInteger(0);

    public void lock(){
        while (!status.compareAndSet(0, 1)) {
            Thread.yield();
        }
    }

    public void unlock(){
        status.set(0);
    }
}
           

public static void yieldLockTest() {
    List<Thread> list = new ArrayList<>();
    YieldLock lock = new YieldLock();
    for (int i = 0; i < 10; i++) {
        Thread t1 = new Thread(()->{
            lock.lock();
            for (int j = 0; j < 10; j++) {
                System.out.print(Thread.currentThread().getName()+" "+j);
            }
            System.out.println();
            lock.unlock();
        },"线程-"+i);
        list.add(t1);
    }
    list.forEach(t->t.start());
}
           

第三种方案：sleep+自旋

和yield不一样，他不考虑优先级问题

public class SleepLock {
    // 0：无锁
    private volatile AtomicInteger status = new AtomicInteger(0);

    public void lock(){
        while (!status.compareAndSet(0, 1)) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public  void unlock(){
        status.set(0);
    }
}
           

public static void sleepLockTest() {
    List<Thread> list = new ArrayList<>();
    SleepLock lock = new SleepLock();
    for (int i = 0; i < 10; i++) {
        Thread t1 = new Thread(()->{
            lock.lock();
            for (int j = 0; j < 10; j++) {
                System.out.print(Thread.currentThread().getName()+" "+j);
            }
            System.out.println();
            lock.unlock();
        },"线程-"+i);
        list.add(t1);
    }
    list.forEach(t->t.start());
}
           

第四种方案：park

unsafe提供给jdk底层使用，当我们使用时会坚持是否时“受信任”的类，jdk也提供了第三方工具类LockSupport；

这里park会阻塞线程，然后再调用unpark的时候，从park方法出继续执行；这样的方式使得线程按排队时间长短获取锁，比上面的方法更为公平。

public class ParkLook {
    // 0：无锁
    private AtomicInteger status = new AtomicInteger(0);

    // 装载等待的线程
    private List<Thread> list = new ArrayList<>();

    public void lock(){
        while (!status.compareAndSet(0, 1)) {
            list.add(Thread.currentThread());
            LockSupport.park();
        }
    }

    public void unlock(){
        status.compareAndSet(1,0);
        if(list.size() > 0) {
            Thread thread = list.get(0);
            list.remove(0);
            LockSupport.unpark(thread);
        }
    }
}
           

public static void parkLockTest(){
    List<Thread> list = new ArrayList<>();
    ParkLook lock = new ParkLook();
    for (int i = 0; i < 10; i++) {
        Thread t1 = new Thread(()->{
            lock.lock();
            for (int j = 0; j < 10; j++) {
                System.out.print(Thread.currentThread().getName()+" "+j);
            }
            System.out.println();
            lock.unlock();
        },"线程-"+i);
        list.add(t1);
    }
    list.forEach(t->t.start());
}
           

在最后一个方法中就已经能够看出AQS的一个样貌了，那么什么是AQS呢？

AbstractQueuedSynchronizer简称AQS，Doug lea设计的提供实现阻塞锁和一些列依赖FIFO等待队列的同步器框架。在synchronized优化之前Doug lea写的这个并发框架性能是很高的，小米首席架构师崔宝秋说过：要多看优秀的代码，这样才能写出优秀的代码。下一篇我们就慢慢看源码。