JAVA的Lock锁接口实现

上次主要说的就是锁，锁的应用，梳理了锁的原理，其实你会发现，没有太多技巧性的内容点，这个不容易看明白，先明白原理在看代码。这个更方便理解。学习的过程就是：采坑，入坑，回头看看风景不错。本次主要围绕JUC开发，里面有很多类。

（一）Lock的核心API

介绍

LOCK也提供同步的特性，但是为什么必须使用锁，想比较同步而言，它的灵活性更加高，提供了一系列的API。同步关键字synchronized，要么是执行完，如果没执行完的话需要一直等待。Lock类里面有个trylock() ，就是试一下，如果拿到拿不到锁，就立刻返回，还可以设置等待时间，lock.tryLock(10000L, TimeUnit.MILLISECONDS)。使用它的主要原因，就是灵活。并不是因为性能高。

常用方法

1.lock

获取锁的方法，若锁被其他线程获取，则等待（阻塞）

2.lockInterruptbly

在锁的获取过程中可以中断当前线程

3.tryLock

尝试非阻塞地获取锁，立即返回

4.unlock

释放锁

代码演示

import java.util.concurrent.locks.ReentrantLock;

// 演示可重入

public class ReentrantDemo1 {

private static final ReentrantLock lock = new ReentrantLock();

public static void main(String[] args) {

lock.lock(); // block until condition holds

try {

System.out.println("第一次获取锁");

System.out.println("当前线程获取锁的次数" + lock.getHoldCount());

lock.lock();

System.out.println("第二次获取锁了");

System.out.println("当前线程获取锁的次数" + lock.getHoldCount());

} finally {

lock.unlock();

lock.unlock();

}

System.out.println("当前线程获取锁的次数" + lock.getHoldCount());

// 如果不释放，此时其他线程是拿不到锁的

new Thread(() -> {

System.out.println(Thread.currentThread() + " 期望抢到锁");

lock.lock();

System.out.println(Thread.currentThread() + " 线程拿到了锁");

}).start();

}

}

第一个线程拿到锁，第二个线程执行要做的下面的事情，如果第一个线程不释放锁的话，其他线程是拿不到锁的，可重入就是同一把锁被锁了多次，都释放后这个锁就没被使用了，可重入是同一个线程的意思。

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

// 可响应中断

public class LockInterruptiblyDemo1 {

private Lock lock = new ReentrantLock();

public static void main(String[] args) throws InterruptedException {

LockInterruptiblyDemo1 demo1 = new LockInterruptiblyDemo1();

Runnable runnable = new Runnable() {

@Override

public void run() {

try {

demo1.test(Thread.currentThread());

} catch (InterruptedException e) {

e.printStackTrace();

}

}

};

Thread thread1 = new Thread(runnable);

Thread thread2 = new Thread(runnable);

thread1.start();

Thread.sleep(500); // 等待0.5秒，让thread1先执行

thread2.start();

Thread.sleep(2000); // 两秒后，中断thread2

thread2.interrupt();

}

public void test(Thread thread) throws InterruptedException {

System.out.println(Thread.currentThread().getName() + "， 想获取锁");

lock.lockInterruptibly(); //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出

try {

System.out.println(thread.getName() + "得到了锁");

Thread.sleep(10000); // 抢到锁，10秒不释放

} finally {

System.out.println(Thread.currentThread().getName() + "执行finally");

lock.unlock();

System.out.println(thread.getName() + "释放了锁");

}

}

}

响应中断的lockInterruptibly，就是响应了不继续等待。

（二） 读写锁的实现

介绍

维护一对关联锁，一个用于只读操作，一个用于写入，读锁可以由多个读线程同时持有，写锁是排他的。适合读取线程比写入线程多的场景，改进互斥锁的性能。

场景

缓存组件，集合的并发线程安全性改造。

示例

不用读写锁

public class ReentrantReadWriteLockDemo1 {

public static void main(String[] args) {

final ReentrantReadWriteLockDemo1 readWriteLockDemo1 = new ReentrantReadWriteLockDemo1();

// 多线程同时读/写

new Thread(() -> {

readWriteLockDemo1.read(Thread.currentThread());

}).start();

new Thread(() -> {

readWriteLockDemo1.write(Thread.currentThread());

}).start();

new Thread(() -> {

readWriteLockDemo1.read(Thread.currentThread());

}).start();

}

// 不管读写，只有一个线程能用， 独享锁

public synchronized void read(Thread thread) { // 2秒

long start = System.currentTimeMillis();

while(System.currentTimeMillis() - start

System.out.println(thread.getName()+"正在进行“读”操作");

}

System.out.println(thread.getName()+"“读”操作完毕");

}

/** 写 */

public synchronized void write(Thread thread) {

long start = System.currentTimeMillis();

while(System.currentTimeMillis() - start

System.out.println(thread.getName()+"正在进行“写”操作");

}

System.out.println(thread.getName()+"“写”操作完毕");

}

}

通过同步代码块来完成， 独占的话，性能问题，原本修改数据加锁还算可以，但是读数据你也加锁，就说不过去了，线程1-2 就是读数据。一般都是读多写少，为了偶然的一次写导致加锁性能消耗这是不应该的。

读写锁（既保证了读数据的效率，也保证数据的一致性），一个读锁，一个写锁。

看了这个图 应该基本明白了吧

import java.util.concurrent.locks.ReentrantReadWriteLock;

// 读写锁（既保证了读数据的效率，也保证数据的一致性）

public class ReentrantReadWriteLockDemo2 {

ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

public static void main(String[] args) {

final ReentrantReadWriteLockDemo2 readWriteLockDemo2 = new ReentrantReadWriteLockDemo2();

// 多线程同时读/写

new Thread(() -> {

readWriteLockDemo2.read(Thread.currentThread());

}).start();

new Thread(() -> {

readWriteLockDemo2.read(Thread.currentThread());

}).start();

new Thread(() -> {

readWriteLockDemo2.write(Thread.currentThread());

}).start();

}

// 多线程读，共享锁

public void read(Thread thread) {

readWriteLock.readLock().lock();

try {

long start = System.currentTimeMillis();

while (System.currentTimeMillis() - start

System.out.println(thread.getName() + "正在进行“读”操作");

}

System.out.println(thread.getName() + "“读”操作完毕");

} finally {

readWriteLock.readLock().unlock();

}

}

/**

* 写

*/

public void write(Thread thread) {

readWriteLock.writeLock().lock();

try {

long start = System.currentTimeMillis();

while (System.currentTimeMillis() - start

System.out.println(thread.getName() + "正在进行“写”操作");

}

System.out.println(thread.getName() + "“写”操作完毕");

} finally {

readWriteLock.writeLock().unlock();

}

}

}

提供了writeLock 和 readLock ，一个读锁一个写锁，读锁可以共享的。写锁是独立的。当读锁在被多个线程调用的时候，写锁不允许写入数据。

锁降级

锁降级 ：是指保持住当前的写锁（已拥有），再获取读锁，随后释放写锁的过程。

首先写锁是独占的，读锁是共享的，然后读写锁是线程间互斥的，锁降级的前提是所有线程都希望对数据变化敏感，但是因为写锁只有一个，所以会发生降级。

如果先释放写锁，再获取读锁，可能在获取之前，会有其他线程获取到写锁，阻塞读锁的获取，就无法感知数据变化了。所以需要先hold住写锁，保证数据无变化，获取读锁，然后再释放写锁。写可以到读是降级，读不可以到写

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

// 缓存示例

public class CacheDataDemo {

// 创建一个map用于缓存

private Map map = new HashMap();

private static ReadWriteLock rwl = new ReentrantReadWriteLock();

public static void main(String[] args) {

// 1 读取缓存里面的数据

// cache.query()

// 2 如果换成没数据,则取数据库里面查询 database.query()

// 3 查询完成之后,数据塞到塞到缓存里面 cache.put(data)

}

public Object get(String id) {

Object value = null;

// 首先开启读锁，从缓存中去取

rwl.readLock().lock();

try {

if (map.get(id) == null) {

// TODO database.query(); 全部查询数据库 ,缓存雪崩

// 必须释放读锁

rwl.readLock().unlock();

// 如果缓存中没有释放读锁，上写锁。如果不加锁，所有请求全部去查询数据库，就崩溃了

rwl.writeLock().lock(); // 所有线程在此处等待 1000 1 999 (在同步代码里面再次检查是否缓存)

try {

// 双重检查，防止已经有线程改变了当前的值，从而出现重复处理的情况

if (map.get(id) == null) {

// TODO value = ...如果缓存没有，就去数据库里面读取

}

rwl.readLock().lock(); // 加读锁降级写锁,这样就不会有其他线程能够改这个值，保证了数据一致性

} finally {

rwl.writeLock().unlock(); // 释放写锁@

}

}

} finally {

rwl.readLock().unlock();

}

return value;

}

}

（三）同步锁的本质-排队

1.同步的方式

独享锁-单个队列窗口，共享锁-多个队列窗口

2.强锁的方式

插队抢（不公平锁），先来后到抢锁（公平锁）

3.没抢到锁的处理方式

快速尝试多次（CAS自旋锁）阻塞等待

唤醒阻塞线程的方式（叫号器）

全部通知，通知下一个

（四）AQS抽象队列同步器

介绍

对资源占用，释放，线程的等待，唤醒等等接口和具体实现

AQS是AbustactQueuedSynchronizer的简称，它是一个Java提供的底层同步工具类，用一个int类型的变量表示同步状态，并提供了一系列的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，例如ReentrantLock，CountdowLatch就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同步组件的内部类。

AQS可重写的方法

在实现同步组件时AQS提供的模板方法

image

AQS提供的模板方法

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

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

查询同步队列中等待线程情况。

同步组件通过AQS提供的模板方法实现自己的同步语义。

八个方法

1.acquire，acquireShared

定义了资源争用的逻辑，如果没拿到，则等待。

2.tryAcquire，tryAcquireShared

实际直行占用资源的操作，如何判定一个由使用者具体去实现。

3.release，releaseShared

释放资源的逻辑，释放之后，通知后续节点进行争抢。

4.tryRelease，tryReleaseShared

实际执行资源释放的操作，具体的AQS使用者来实现。

PS：AQS提供了三大功能：独占锁、共享锁、ConditionObject。子类在实现中，可以实现其一部分方法。其编程思想值得借鉴，通过超类实现基本的处理流程，将其中部分抽成未实现方法，默认抛出异常，由子类实现，这种解耦方式，最大化的减少了代码的重复，且便于子类在实现中个性化自己的处理逻辑。