java中的锁---Lock

参考:https://www.cnblogs.com/cl1024cl/p/6205013.html
https://www.cnblogs.com/myseries/p/10784076.html
https://blog.csdn.net/caideb/article/details/85289790
https://blog.csdn.net/luxia_24/article/details/52403033
https://blog.csdn.net/qq_37997523/article/details/104680535
https://blog.csdn.net/weixin_44742132/article/details/105852446

与synchronized的区别
synchronized是JVM层面的, Lock是代码层面的
synchronized自动释放, Lock必须手动释放
synchronized非公平锁. Lock默认非公平锁,但可以设置成公平锁
两者都是可重入锁

ReentrantReadWriteLock提供了读锁和写锁，允许多个线程获得读锁、而只能有一个线程获得写锁。读锁和写锁不能同时获得。
synchronized不是可中断锁，而Lock是可中断锁(如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。在前面演示tryLock(long time, TimeUnit unit)和lockInterruptibly()的用法时已经体现了Lock的可中断性。)

Lock的实现类有 ReentrantLock, ReentrantReadWriteLock(ReadLock,WriteLock)实现的是ReadWriteLock接口,ReadWriteLock接口中的变量是Lock接口

Lock常用方法:
1). lock():就是用来获取锁。如果锁已被其他线程获取，则进行等待。在前面已经讲到，如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁,释放锁,常放在finally{}中
2). tryLock() & tryLock(long time, TimeUnit unit) 如果获取成功，则返回true；如果获取失败，则返回false.
tryLock(long time, TimeUnit unit) 如果一开始拿到锁或者在等待期间内拿到了锁，则返回true 否则返回false
3). lockInterruptibly(),这个方法比较特殊,当通过这个方法去获取锁时，如果线程 正在等待获取锁，则这个线程能够 响应中断，即中断线程的等待状态。
例如，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
4). unlock()方法是用来释放锁的

Lock的实现类 ReentrantLock(直接实现Lock接口)
构造方法有俩
ReentrantLock() 默认非公平锁
ReentrantLock(boolean fair) fair为True则是公平锁
公平锁和非公平锁的实现原理:https://zhuanlan.zhihu.com/p/94015814
https://blog.csdn.net/jsj13263690918/article/details/84552716
https://blog.csdn.net/qq_28834355/article/details/108690540

先说公平锁:
公平锁加锁调用

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

tryAcquire(arg) ：此处尝试获取锁，true获取成功并且return，false获取失败并执行下一步代码

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState(); //0表示当前锁没有被加锁,>0则表示没有被释放的数量(可重入锁)
            if (c == 0) {
                if (!hasQueuedPredecessors() &&            //hasQueuedPredecessors() 判断有没有等待线程 队列中没有其他线程才获取锁,这是公平锁
                    compareAndSetState(0, acquires)) {     //使用CAS设置锁对象为加锁状态,
					setExclusiveOwnerThread(current);      //设置独占线程是当前线程
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {   //锁对象已经加锁,且加锁线程刚好就是当前线程,
                int nextc = c + acquires;                      //直接给state +1 (所以,重入时状态就是+1了)
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
addWaiter：给等待队列添加一个节点，标记当前线程正在等待获取锁，返回当前添加的节点Node
acquireQueued：死循环（自旋锁）的方式，等待获取到锁资源，成功获取了才return
AQS 中的队列是由 Node 节点组成的双向链表实现的。
首先判断队列是否为空，不为空时则将封装好的 Node 利用 CAS 写入队尾，如果出现并发写入失败就需要调用 enq(node); 来写入了
写入队列之后需要将当前线程挂起(利用acquireQueued(addWaiter(Node.EXCLUSIVE), arg))：直到最后线程被唤起

非公平锁的实现:

final void lock() {
            if (compareAndSetState(0, 1))   //上来就直接用CAS尝试获取锁
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);  //后面跟公平锁一样了
        }

释放锁:
公平锁和非公平锁的释放流程都是一样的
public void unlock() {
sync.release(1);
}
首先会判断当前线程是否为获得锁的线程，由于是重入锁所以需要将 state 减到 0 才认为完

全释放锁。
释放之后需要调用 unparkSuccessor(h) 来唤醒被挂起的线程。

ReadWriteLock(读写锁)的实现原理:
参考: https://blog.csdn.net/yupi1057/article/details/80787013
https://blog.csdn.net/FYGu18/article/details/81784574
可同读,但读写互斥
ReadWriteLock 的主要实现为 ReentrantReadWriteLock ，其提供了以下特性：
公平性选择：支持公平与非公平（默认）的锁获取方式，吞吐量非公平优先于公平。
可重入：读线程获取读锁之后可以再次获取读锁，写线程获取写锁之后可以再次获取写锁
可降级：写线程获取写锁之后，其还可以再次获取读锁，然后释放掉写锁，那么此时该线程是读锁状态，也就是降级操作。

ReentrantReadWriteLock 的核心是由一个基于AQS的同步器 Sync 构成，然后由其扩展出 ReadLock （共享锁）， WriteLock （排它锁）所组成。
源码:读写锁,而是默认非公平锁,参数为True为公平锁

public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

读锁的获取:

// ReadLock
public void lock() {
    sync.acquireShared(1);
}
// AQS
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)  // 这里是最重要的
        doAcquireShared(arg);    //获取失败之后AQS中入队操作，等待被唤醒后重新获取
}

源码读起来比较费劲,…,所以只说一下大概流程
https://blog.csdn.net/yupi1057/article/details/80787013
获取读锁的操作步骤是:
操作1：读写需要互斥，因此当存在写锁并且持有写锁的线程不是该线程时获取失败。
操作2：是否存在等待写锁的线程，存在的话则获取读锁需要等待，避免写锁饥饿。(写锁优先级是比较高的)
操作3：CAS获取读锁，实际上是state字段的高16位自增。
操作4：获取成功后再ThreadLocal中记录当前线程获取读锁的次数。读锁获取后会在readHolds记录当前线程信息

读锁释放:
1,清理ThreadLocal中保存的获取锁数量信息
2,CAS修改读锁个数，实际上是自减一
3,唤醒其他线程

写锁的获取:
获取入口:

// WriteLock
    public void lock() {
        sync.acquire(1);
    }
// AQS
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

主要方法也是 tryAcquire()
流程大概是:
1,存在读锁或者写锁且锁的持有对象不是当前线程,则获取失败.如果获取成功,则锁状态加一 返回tue
2,如果不存在加锁,有一个 if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) return false;
writerShouldBlock() 公平锁 加队列里, 非公平锁直接返回false(返回false就开始竞争(CAS))
3,获取锁之后将,将排他锁的持有对象设为当前线程

写锁释放

protected final boolean tryRelease(int releases) {
            if (!isHeldExclusively())    //当前排他锁只有对象不是当前线程最直接报错
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;  //
            if (free)        //可重入锁锁释放完毕,才能把排他锁持有对象清空
                setExclusiveOwnerThread(null);  //清除排他锁占有状态
            setState(nextc); //加锁状态 -1
            return free;
        }

锁降级:
指的是一个线程获取写锁之后再获取读锁 (写锁的级别要高)
降级操作是为了获取可见性

锁可以降级,但是不能升级
先获读锁,然后再次获取写锁,会产生死锁