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

2024-05-01 22:08

本文主要是介绍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

相关文章

Spring 请求之传递 JSON 数据的操作方法

《Spring请求之传递JSON数据的操作方法》JSON就是一种数据格式,有自己的格式和语法,使用文本表示一个对象或数组的信息,因此JSON本质是字符串,主要负责在不同的语言中数据传递和交换,这... 目录jsON 概念JSON 语法JSON 的语法JSON 的两种结构JSON 字符串和 Java 对象互转

JAVA保证HashMap线程安全的几种方式

《JAVA保证HashMap线程安全的几种方式》HashMap是线程不安全的,这意味着如果多个线程并发地访问和修改同一个HashMap实例,可能会导致数据不一致和其他线程安全问题,本文主要介绍了JAV... 目录1. 使用 Collections.synchronizedMap2. 使用 Concurren

Java Response返回值的最佳处理方案

《JavaResponse返回值的最佳处理方案》在开发Web应用程序时,我们经常需要通过HTTP请求从服务器获取响应数据,这些数据可以是JSON、XML、甚至是文件,本篇文章将详细解析Java中处理... 目录摘要概述核心问题:关键技术点:源码解析示例 1:使用HttpURLConnection获取Resp

python实现svg图片转换为png和gif

《python实现svg图片转换为png和gif》这篇文章主要为大家详细介绍了python如何实现将svg图片格式转换为png和gif,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录python实现svg图片转换为png和gifpython实现图片格式之间的相互转换延展:基于Py

Python利用ElementTree实现快速解析XML文件

《Python利用ElementTree实现快速解析XML文件》ElementTree是Python标准库的一部分,而且是Python标准库中用于解析和操作XML数据的模块,下面小编就来和大家详细讲讲... 目录一、XML文件解析到底有多重要二、ElementTree快速入门1. 加载XML的两种方式2.

Java的栈与队列实现代码解析

《Java的栈与队列实现代码解析》栈是常见的线性数据结构,栈的特点是以先进后出的形式,后进先出,先进后出,分为栈底和栈顶,栈应用于内存的分配,表达式求值,存储临时的数据和方法的调用等,本文给大家介绍J... 目录栈的概念(Stack)栈的实现代码队列(Queue)模拟实现队列(双链表实现)循环队列(循环数组

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作。由于数据类

Python实现图片分割的多种方法总结

《Python实现图片分割的多种方法总结》图片分割是图像处理中的一个重要任务,它的目标是将图像划分为多个区域或者对象,本文为大家整理了一些常用的分割方法,大家可以根据需求自行选择... 目录1. 基于传统图像处理的分割方法(1) 使用固定阈值分割图片(2) 自适应阈值分割(3) 使用图像边缘检测分割(4)

Android实现在线预览office文档的示例详解

《Android实现在线预览office文档的示例详解》在移动端展示在线Office文档(如Word、Excel、PPT)是一项常见需求,这篇文章为大家重点介绍了两种方案的实现方法,希望对大家有一定的... 目录一、项目概述二、相关技术知识三、实现思路3.1 方案一:WebView + Office Onl

Java中Switch Case多个条件处理方法举例

《Java中SwitchCase多个条件处理方法举例》Java中switch语句用于根据变量值执行不同代码块,适用于多个条件的处理,:本文主要介绍Java中SwitchCase多个条件处理的相... 目录前言基本语法处理多个条件示例1:合并相同代码的多个case示例2:通过字符串合并多个case进阶用法使用