JAVA学习——基于AQS的ReentrantLock公平锁和非公平锁的实现

2024-05-01 22:08
文章标签 java 实现 学习 公平 aqs reentrantlock

本文主要是介绍JAVA学习——基于AQS的ReentrantLock公平锁和非公平锁的实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

之前笔者解析了AQS的源码，在JUC中有很多锁是基于AQS实现的，今天想写个简单的ReentrantLock实现，代码也基本是在看了ReentrantLock源码后写出来的，做个笔记。

总结一下AQS的原理，就是使用一个int类型来表示可申请的锁资源，提供了一系列的原子操作，以及用于放置申请锁的线程的等待队列。实际上定义了一整套完整的多线程访问共享资源的同步框架，具体的解析可以看我的另一篇文章

ReentrantLock非公平锁的实现

首先来看ReentrantLock的非公平锁实现，它的类定义：

public class UnfairReentrantLockImpl extends AbstractQueuedSynchronizer implements Lock, Serializable

非公平锁实现了Lock接口，因此需要实现以下的方法：
在这里插入图片描述
基本上只要了解接口的语义，基于AQS提供的接口，可以快速实现Lock的接口功能，代码如下，可以看到AQS提供的是线程同步部分的实现：

	public void lock() {//cas的方式修改state值，如果成功，即获得锁if (compareAndSetState(0, 1)) {setExclusiveOwnerThread(Thread.currentThread());} else {//否则加入等待队列，自旋方式申请锁acquire(1);}}@Overridepublic void unlock() {//释放锁release(1);}@Overridepublic boolean tryLock(long time, TimeUnit unit) throws InterruptedException 			{//阻塞方式申请锁，指定时间后无论是否申请成功都返回return tryAcquireNanos(1, unit.toNanos(time));}@Overridepublic boolean tryLock() {//非阻塞方式申请锁return nofairTryAcquire(1);}@Overridepublic void lockInterruptibly() throws InterruptedException {//可中断式的申请锁acquireInterruptibly(1);}@Overridepublic Condition newCondition() {return new ConditionObject();}//尝试获取锁private final boolean nofairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}} else if (current == getExclusiveOwnerThread()) {//如果当前线程已经持有锁，只修改一下state的值即返回，//体现了可重入锁的特点int nextC = c + acquires;if (nextC < 0) {throw new Error("Maximum lock lcount exceeded");}setState(nextC);return true;}return false;}

ReentrantLock锁继承AQS，必须要实现AQS的两个方法：tryAcquire和tryRelease，这两个方法在AQS只提供了一个抛出异常的实现。tryAcquire的语义是非阻塞式的申请锁，而tryRelease的语义是释放锁，并恢复state的值。在AQS内部，会使用这两个方法构造整个同步器的实现。

    //AbstractQueuedSynchronizer定义的方法，该方法在AbstractQueuedSynchronizer中只有一个抛出异常的默认实现@Overrideprotected boolean tryAcquire(int arg) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (compareAndSetState(0, arg)) {setExclusiveOwnerThread(current);return true;}} else if (current == getExclusiveOwnerThread()) {int nextC = c + arg;if (nextC < 0) {throw new Error("Maximum lock lcount exceeded");}setState(nextC);return true;}return false;}//AbstractQueuedSynchronizer定义的方法，该方法在AbstractQueuedSynchronizer中只有一个抛出异常的默认实现@Overrideprotected boolean tryRelease(int arg) {int c = getState() - arg;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;}

ReentrantLock公平锁的实现
ReentrantLock公平锁强调根据线程等待时间长短来分配锁，等待时间最长的获取锁，在实现上，会让等待队列头部的线程获得锁。
公平锁的代码实现与非公平锁基本一致，主要区别在以下两个方法上，公平锁的lock方法会将申请锁的线程直接加入等待队列，根据等待时间排序来决定获取锁的线程。公平锁的tryAcquire方法在判断一个线程能否获得锁时，会比非公平锁多加入一个请求线程是否为头线程的判断，只有头线程能获得线程。读者可以与非公平锁的这两个方法实现进行对比，即可清楚比较出两者的区别

	@Overridepublic void lock() {//与非公平锁的区别：直接将当前申请锁请求加入队列acquire(1);}@Overrideprotected boolean tryAcquire(int arg) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {//只有在当前线程为头结点时，才能去获得锁if (!hasQueuedPredecessors() && compareAndSetState(0, arg)) {setExclusiveOwnerThread(current);return true;}} else if (current == getExclusiveOwnerThread()) {int nextC = c + arg;if (nextC < 0) {throw new Error("Maximum lock count exceeded");}setState(nextC);return true;}return false;}

ReentrantLock的测试

最后，给出一个简单的测试类，这个测试类创建了10个银行账户，初始金额都为1000元，然后有30个管理线程，会随机挑选两个账户，转账一个10以内的随机金额，每个线程独立转账10次。完成所有的转账操作后，计算所有账户总金额，如果总金额与原来一致，证明整个转账过程没有同步错误。


public class LockTest {private static Account[] accounts = new Account[10];private static AccountManager[] threads = new AccountManager[30];public static void main(String[] args) throws Exception {for (int i = 0; i < 10; i++) {accounts[i] = new Account(1000);}double sum = 0;for (int i = 0; i < 10; i++) {sum += accounts[i].getMoney();}System.out.println("src sum：" + sum);for (int i = 0; i < 30; i++) {threads[i] = new AccountManager();threads[i].start();}for (int i = 0; i < 30; i++) {threads[i].join();}sum = 0;for (int i = 0; i < 10; i++) {sum += accounts[i].getMoney();}System.out.println("after operation sum：" + sum);for (int i = 0; i < accounts.length; i++) {System.out.println("acount-" + i + " res money: " + accounts[i].getMoney());}}private static class AccountManager extends Thread {@Overridepublic void run() {int index = 10;int fromAccount = 0, toAccount = 0;while (index > 0) {fromAccount = (int) (Math.random() * 10);toAccount = (int) (Math.random() * 10);if (toAccount == fromAccount) {toAccount = (toAccount + 1) % 10;}try {AccountMgr.transfer(accounts[fromAccount], accounts[toAccount], Math.random() * 10);} catch (Exception e) {e.printStackTrace();}index--;System.out.println(Thread.currentThread() + " complete " + (10 - index) + " transformation from " + fromAccount + " to " + toAccount);}}}
}public class Account {private Lock lock = new FairReentrantLockImpl();private volatile double money;public Account(final double money) {this.money = money;}public void add(double money) {lock.lock();try {this.money += money;} finally {lock.unlock();}}public void reduce(double money) {lock.lock();try {this.money -= money;} finally {lock.unlock();}}public double getMoney() {return money;}void lock() {lock.lock();}void unLock() {lock.unlock();}boolean tryLock() {return lock.tryLock();}
}
public class AccountMgr {public static boolean tryTransfer(Account from, Account to, Double money) throws NoEnoughMoneyException {if (from.tryLock()) {try {if (to.tryLock()) {try {if (from.getMoney() >= money) {from.reduce(money);to.add(money);} else {System.out.println("operation failed ");
//                            throw new NoEnoughMoneyException();}return true;} finally {to.unLock();}}} finally {from.unLock();}}return false;}public static void transfer(Account from, Account to, Double money) throws NoEnoughMoneyException {boolean success = false;do {success = tryTransfer(from, to, money);if (!success)Thread.yield();} while (!success);}public static class NoEnoughMoneyException extends Exception {}
}

这篇关于JAVA学习——基于AQS的ReentrantLock公平锁和非公平锁的实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/952781。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2