Java并发编程之锁原理

1、基础概念

根据对资源是否能够同时使用，把锁分为独占锁和共享锁。独占锁：与具体线程相关，一个线程获取到锁资源后，就会标记这个线程获取到了该资源，其他线程在尝试获取资源时，就会失败而被阻塞。共享锁：与具体线程不相关，当多个线程去请求资源时，通过CAS（compare and swap）方式竞争资源，当一个线程获取到资源后，其他线程再次去获取时如果当前资源还能满足它的要求，则当前线程只需要使用CAS方式进行获取即可。

2. AQS原理分析

2.1 AQS（abstract queue synchronizer）抽象同步队列。

是实现同步器的基础组件，Java并发包中锁的底层是基于AQS实现。AQS类图关系如下：

 

AQS是一个双向的FIFO队列，通过head节点和tail节点标记头队列首尾元素。节点元素Node中的thread变量存放等待线程。State变量表示锁的状态。ConditionObject 条件变量为内部类，每个条件变量对应一个条件队列，用来存放因调用条件变量wait方法而被阻塞的线程。

2.2 获取锁的过程

AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

当线程1通过CAS竞争拿到资源后，其他线程则进入等待队列，通过CAS方式循环遍历state状态值的方式来获取锁。每个节点都必须设置前置节点的 waitStatus状态为 SIGNAL（唤醒下一个节点），防止重复释放锁，所以必须要一个前置节点，而这个前置节点，实际上就是当前持有锁的节点。

2.3 Synchronize与AQS实现线程同步的区别

Synchronize内置锁配合notify()和wait()，实现线程间同步。

AQS的条件变量的signal()和await()方法也可实现线程间的同步。

区别：

1、synchronized同时只能与一个共享变量的notify/wait方法实现同步

2、AQS一个锁可以对应多个条件变量

AQS同步队列与条件队列的关系

如图所示，AQS同步器的线程等待队列中有节点A（线程A）和节点B（线程B），节点A自旋state状态值，通过CAS方式竞争拿到资源锁。

public void aqstest() throws Exception {
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    Thread th1 = new Thread(() -> {
        System.out.println(Thread.currentThread() +"start");

        try {
            lock.lock();
            condition.await();
            System.out.println(Thread.currentThread() +"await");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    });
    Thread th2 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread() +"start");
            try {
                Thread.sleep(1000);
                lock.lock();
                condition.signal();
                System.out.println(Thread.currentThread() +"signal");

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    });
    th1.start();
    th2.start();
    th1.join();
    th2.join();
    System.out.println(Thread.currentThread() +"end");
}

线程A调用await（）方法，节点A则被放入条件等待队列中等待被唤醒。直到其他线程调用该条件变量的signal()、singalAll()方法，线程A才被唤醒。

3. 独占锁-ReentrantLock

ReentrantLock是可重入的独占锁，同时只能有一个线程可以获得该锁，其他未获取该锁的线程会被阻塞而放入到该锁的AQS阻塞队列里。ReentrantLock的类图关系如下

 state状态值表示线程获取该锁的可重入次数。在默认情况下， state的值为 0 表示当前锁没有被任何线程持有。请求锁CAS成功则state加1，在该线程没有释放锁的情况下第二次获取该锁，state值再加1,。释放锁时，尝试CAS让state减1，如果state=1，则当前线程释放该锁。ReentrantLock默认的为非公平锁，其获取锁的过程如下：

非公平锁的体现在于：非AQS等待队列中的线程通过CAS方式竞争锁时，不会先判断等待队列中是否有等待线程，直接通过CAS方式竞争锁（抢夺策略）。因此，存在非等待队列中的线程（后来的线程）比等待队列中的线程（之前的线程）先获取到锁。而公平锁的方式下，非等待队列中的线程在竞争锁资源之前，会查看队列中是否有等待线程，如果有，则将该线程插入到AQS等待队列的尾部。

4. 组合锁-ReentrantReadWriteLock

ReentrantReadWriteLock的类图关系如下，同样是基于AQS实现。ReentrantReadWriteLock 锁由WriteLock和ReadLock构成。且巧妙地使用 state 的高 16 位表示读状态，也就是获取到读锁的次数；使用低 16 位表示获取到写锁的线程的可重入次数。

4.1 WriteLock—写锁 获取锁过程

如下图所示为获取写锁过程。

线程获取到写锁的条件：没有其他线程占用读锁 且 没有其他线程占用写锁。

4.2 ReadLock—读锁

获取读锁的过程如下图，根据分析获得读锁的条件（二者满足其一）：

1、没有其他线程占有写锁。

2、持有写锁和调用读锁的是同一个线程

4.3 锁降级的必须要性

锁降级概念：

锁降级指的是写锁降级成为读锁。如果当前线程拥有写锁，然后将其释放，最后再获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指把持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。

 

原因：一个事务线程不希望自己的操作被别的线程中断，而这个事务操作可能分成多部分操作更新不同的数据（或表）甚至非常耗时。如果长时间用写锁独占，显然对于某些高响应的应用是不允许的，所以在完成部分写操作后，退而使用读锁降级，来允许响应其他进程的读操作。只有当全部事务完成后才真正释放锁。

必要性：答案是必要的。主要是为了保证数据的可见性。如果当前线程不获取读锁而是直接释放写锁， 假设此刻另一个线程（记作线程T）获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新。

 

白话：

1、线程不释放写锁，其他线程将被阻塞。

2、线程A释放锁后，如果被其他线程获取了写锁，线程A则获取不到读锁。所以先获取读锁再释放写锁。

可参考资料：

https://www.cnblogs.com/skywang12345/p/java_threads_category.html

《Java并发编程之美》