首页
学习
活动
专区
工具
TVP
发布
精选内容/技术社群/优惠产品,尽在小程序
立即前往

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。子类在实现中,可以实现其一部分方法。其编程思想值得借鉴,通过超类实现基本的处理流程,将其中部分抽成未实现方法,默认抛出异常,由子类实现,这种解耦方式,最大化的减少了代码的重复,且便于子类在实现中个性化自己的处理逻辑。

  • 发表于:
  • 原文链接https://kuaibao.qq.com/s/20200812A0TFNR00?refer=cp_1026
  • 腾讯「腾讯云开发者社区」是腾讯内容开放平台帐号(企鹅号)传播渠道之一,根据《腾讯内容开放平台服务协议》转载发布内容。
  • 如有侵权,请联系 cloudcommunity@tencent.com 删除。

扫码

添加站长 进交流群

领取专属 10元无门槛券

私享最新 技术干货

扫码加入开发者社群
领券