【并发编程】AQS——详细解释公平锁，非公平锁，独占锁，什么是可重入以及condition

目录

1、公平

2.非公平

3.独占锁

4.可重入

5.condition

---

1、公平

第一步：获取状态的 state 的值。如果 state=0 即代表锁没有被其它线程占用，执行第二步。如果 state!=0 则代表锁正在被其它线程占用，执行第三步。
第二步：判断队列中是否有线程在排队等待。如果不存在则直接将锁的所有者设置成当前线程，且更新状态 state 。如果存在就入队。
第三步：判断锁的所有者是不是当前线程。如果是则更新状态 state 的值。如果不是，线程进入队列排队等待。

2.非公平

第一步：获取状态的 state 的值。如果 state=0 即代表锁没有被其它线程占用，则设置当前锁的持有者为当前线程，该操作用 CAS 完成。如果不为0或者设置失败，代表锁被占用进行下一步。
此时获取 state 的值，如果是0，代表刚好线程释放了锁，此时将锁的持有者设为自己如果不是0，则查看线程持有者是不是自己如果是，则给state+1，获取锁如果不是，则进入队列等待

3.独占锁

AQS 在锁的获取时，并不一定只有一个线程才能持有这个锁，所以此时有了 独占模式和共享模式 的区别，我们本篇文章中的 ReentrantLock 使用的就是独占模式，在多线程的情况下只会有一个线程获取锁。

4.可重入

可重入锁就是当前持有锁的线程能够多次获取该锁，无需等待

AQS实现一个可重入锁

 package com;
 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
 
public class MyLock implements Lock {
    private Helper helper = new Helper();
 
    private class Helper extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
            // 第一个线程进来，可以获取锁
            // 第二个线程进来，无法获取锁，返回false
            Thread thread = Thread.currentThread();
            // 判断是否为第一个线程进来
            int state = getState();
            if (state == 0) {
                if (compareAndSetState(0, arg)) {// 如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值
                    // 设置当前线程
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
            } else if(getExclusiveOwnerThread() == thread) { // 允许重入锁,当前线程和当前保存的线程是同一个线程
                setState(state + 1);
                return true;
            }
            return false;
        }
 
        /***
         * 释放锁
              此方法总是由正在执行释放的线程调用。
         */
        @Override
        protected boolean tryRelease(int arg) {
            // 锁的获取和释放肯定是一一对应的，那么调用此方法的线程一定是当前线程
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new RuntimeException();
            }
            
            boolean flag = false;
            int state = getState() -arg;
            if (state == 0) {// 当前锁的状态正确
                setExclusiveOwnerThread(null);
                flag = true;
            }
            setState(state);
            return flag;
        }
 
        protected Condition newCondition() {
            return new ConditionObject();
        }
    }
 
    @Override
    public void lock() {
        // 独占锁
        helper.acquire(1);
    }
 
    @Override
    public void lockInterruptibly() throws InterruptedException {
        // 可中断
        helper.acquireInterruptibly(1);
    }
 
    @Override
    public boolean tryLock() {
        return helper.tryAcquire(1);
    }
 
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return helper.tryAcquireNanos(1, unit.toNanos(time));
    }
 
    @Override
    public void unlock() {
        helper.release(1);
    }
 
    @Override
    public Condition newCondition() {
        return helper.newCondition();
    }
}

5.condition

在Java并发编程中，每个Java堆中的对象在“出生”的时刻都会“伴生”一个监视器对象，而每个Java对象都会有一组监视器方法：wait()、notify()以及notifyAll()。我们可以通过这些方法实现Java多线程之间的协作和通信，也就是等待唤醒机制，如常见的生产者-消费者模型。但是关于Java对象的这组监视器方法我们在使用过程中，是需要配合synchronized关键字才能使用，因为实际上Java对象的等待唤醒机制是基于monitor监视器对象实现的。与synchronized关键字的等待唤醒机制相比，Condition则更为灵活，因为synchronized的notify()只能随机唤醒等待锁的一个线程，而Condition则可以更加细粒度的精准唤醒等待锁的某个线程。与synchronized的等待唤醒机制不同的是，在monitor监视器模型上，一个对象拥有一个同步队列和一个等待队列，而AQS中一个锁对象拥有一个同步队列和多个等待队列。对象监视器Monitor锁实现原理如下：