AQS对基本概念的实现

最新推荐文章于 2023-05-22 16:11:58 发布
最新推荐文章于 2023-05-22 16:11:58 发布
阅读量311 收藏
点赞数
分类专栏： J.U.C 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluedraam_pp/article/details/122914882
版权

非公平锁

公平锁如何实现的呢？我们来看看 ReentranLock 中的 NonfairSync 类，这个类中就实现了对非公平锁的实现。

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

这段逻辑中，我们可以发现，线程是直接取修改 state 的状态，这代表竞争锁，如果竞争到锁，就执行业务逻辑，如果竞争不到锁再执行 acquire 方法。不排队就是非公平锁。

公平锁

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

公平锁呢，就需要先看看队列中是否有等待的线程，如果没有才取竞争锁，如果等待的队列中有线程，则返回 false ， 线程进入排队的逻辑。

可重入

先来探讨一下，在什么情况下需要锁的可重入性。我们现在知道了 sychronized 这个关键字修饰方法的方法，其实是在对象头上上的锁。所以下面代码中，

public class ReentranTest {
    public static synchronized void add(){
        System.out.println("add in");
        update();
        System.out.println("add out");

    }

    private static synchronized void update() {
        System.out.println("update in ");
        System.out.println("do something");
        System.out.println("update out ");
    }

    public static void main(String[] args) {
        add();
    }

执行的结果如下所示：

add in
update in 
do something
update out 
add out

在执行某个操作的时候，需要先调用 add ,然后在 add 中，调用 update() 此时，同一个线程是可以进入的。如果 sychronized 底层代码没有考虑可重入性，那么当执行到 update() 的时候，状态（这里比较复杂，sychronized 涉及到了锁的升级，这个升级已经考虑了可重入性）已经被改变了，update 方法是不能进入的。我们拿 ReetrantLock 来说明吧，请看下面的例子，如下面的例子：

package interview;

import java.util.concurrent.locks.ReentrantLock;

public class ReentranTestV2 {
    public static ReentrantLock lock = new ReentrantLock();
    public static void add(){
        lock.lock();
        try {
            System.out.println("add in");
            update();
            System.out.println("add out");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    private static void update() {
        lock.lock();
        try {
            System.out.println("update in ");
            System.out.println("do something");
            System.out.println("update out ");
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        add();
    }
}

当执行当 update() 的时候，同一个线程会再次申请同一把锁，如果锁不能重入 ，则线程会死锁在 update() 代码里面。从 ReetrantLock 的 tryAquire() 代码中可以看到，如果不进行可重入处理，那么会返回 false，则进行入等待队列的环节，这样的话就自己被自己锁住了。

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

条件队列

条件队列是一个进程间通信的问题。它是协调多个线程间行为的。例如，1A2B3C的问题。下面是代码，其中，前面两个都是解决 A B C 交题打印的问题，第三个是交替打印 100 次的逻辑。其实解题的思路都是以 flag 这个变量为核心，flag 好比指示灯，不同的指示灯亮起对应着响应线程的动作。具体到每个线程的逻辑就是，当竞争到锁的线程进入到逻辑代码中，先判断 flag 的值，符合条件则执行打印代码，否则执行等待。

import java.util.concurrent.CountDownLatch;
/**
 * 使用的 sychronized 关键字的方式。
 * 这个解题的思路的关键是什么时候该掉 wati 方法和 notify 方法。
 * 当条件不满足的时候，则调用 wait 方法
 * 当满足条件的时候，则执行逻辑代码，最后执行 notify 方法，唤醒其他等待着的线程
 * */
public class A1B2C3 {
    private static int flag = 0 ;
    public static void main(String[] args) {
        Object lock = new Object();
        CountDownLatch cdl = new CountDownLatch(3);
        Thread thread = new Thread(()->{
            synchronized (lock){
                while(flag != 0){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("A");
                flag = 1 ;
                lock.notifyAll();
                cdl.countDown();
            }
        });

        Thread thread1 = new Thread(()->{
            synchronized (lock){
                while(flag != 1){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("B");
                flag = 2 ;
                lock.notifyAll();
                cdl.countDown();
            }
        });
        Thread thread2 = new Thread(()->{
            synchronized (lock){
                while(flag != 2){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("C");
                lock.notifyAll();
                cdl.countDown();
            }
        });
        thread.start();
        thread1.start();
        thread2.start();
        try {
            cdl.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 和  A1B2C3 的解题思路是一样的
 * */
public class A1B2C3Version2 {
    private static int flag = 0 ;
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        CountDownLatch cdl = new CountDownLatch(3);
        Thread thread = new Thread(()->{
            lock.lock();
            try{
                while(flag != 0){
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("A");
                flag = 1 ;
                condition.signalAll();
                cdl.countDown();
            }finally {
                lock.unlock();
            }
        });

        Thread thread1 = new Thread(()->{
            lock.lock();
            try{
                while(flag != 1){
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("B");
                flag = 2 ;
                condition.signalAll();
                cdl.countDown();
            }finally {
              lock.unlock();
            }
        });
        Thread thread2 = new Thread(()->{
            lock.lock();
            try {
                while (flag != 2) {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("C");
                condition.signalAll();
                cdl.countDown();
            }finally {
                lock.unlock();
            }
        });
        thread.start();
        thread1.start();
        thread2.start();
        try {
            cdl.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 这个题目是，使用三个线程接替打印 0 ， 1， 2 三个数字，最后的结果是：
 * 0
 * 1
 * 2
 * 0
 * 1
 * 2
 * ...
 * 0
 * 1
 * 2
 * 这个思路其实和 A1B2C3 的思路差不多，在不符合条件的时候，执行 await 方法
 * 然后等待其他线程执行完毕 sigianl 线程，唤醒当前线程。
 * */
public class A1B2C3for {
    private static int flag = 0 ;
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        List<Integer> list = new ArrayList<Integer>();
        Thread thread = new Thread(()->{
            for(int i = 0 ; i < 100 ; i++){
                lock.lock();
                try{
                    while (flag != 0 ){
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.add(flag);
                    flag = 1 ;
                    condition.signalAll();
                }finally {
                    lock.unlock();
                }
            }
        });
        Thread thread2 = new Thread(()->{
            for(int i = 0 ; i < 100 ; i++){
                lock.lock();
                try{
                    while (flag != 1 ){
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.add(flag);
                    flag = 2;
                    condition.signalAll();
                }finally {
                    lock.unlock();
                }
            }
        });
        Thread thread3 = new Thread(()->{
            for(int i = 0 ; i < 100 ; i++){
                lock.lock();
                try{
                    while (flag != 2 ){
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.add(flag);
                    flag = 0;
                    condition.signalAll();
                }finally {
                    lock.unlock();
                }
            }
        });
        thread.start();
        thread2.start();
        thread3.start();
        try {
            thread.join();
            thread.join();
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i = 0 ; i < 300 ; i++){
            if(i%3 != list.get(i) ){
                System.out.println("false , index:" + i);
            }
        }
    }
}
bluedraam_pp
关注
专栏目录
并发锁核心类AQS学习笔记
01-20
JUC 包中的同步类基本都是基于 AQS 同步器来实现的，如 ReentrantLock，Semaphore 等。 二、原理 1、AQS 工作机制： 如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为...
ReentrantLock源码解析
小英雄
06-21 169
首先来看 ReentrantLock 的两个构造函数： public ReentrantLock() { sync = new NonfairSync(); // 非公平锁 } public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); } 无参的构造函数创建了一个非公平锁NonfairSync，用户也可以根据构造函数，设置一个 boolean 类型的值，来选择使用非公平
AQS源码分析
meser88的博客
05-22 181
我们先来看看重入锁的场景代码// 共享变量// 操作共享变量的方法// 为了演示效果 休眠一下子try {count ++;// 调用了另外一个方法。decr();}finally {try {// 重入锁count--;i++) {首先大家考虑这段代码会死锁吗？大家给我个回复，我看看大家的理解的怎么样好了，有说会死锁的，有说不会，其实这儿是不会死锁的，而且结果就是0.为什么呢？
java锁相关
qq_37478537的博客
08-22 174
synchronized关键字 工具指令介绍： jps：用户查看当前系统中的 java进程 jstack pid ： 用于查看当前进程的堆栈信息 两者结合起来使用：先通过jps找到想要查看的进程的pid，然后再通过 jstack pid来查看该进程的堆栈信息 一、Synchronized锁定范围： 1.synchronized 作用于普通成员方法上时，锁定的是 该方法所属的对象...
ReentrantLock阅读源码，获取锁过程
P01214100的博客
02-26 185
ReentrantLock阅读源码过程 final void lock() { if (compareAndSetState(0, 1)) /**这一步是CAS操作（原子性），多个线程走到这一步（竞争锁），只有一个可以返回true（即只有一个线程会把值修改为1），然后向下运行，其他线程再读的时候就跟期望值0不一致了（刚才那个线程已经设为1了），就会走到else分支了*/ setExclusiveOwnerThread(Thread.currentThread());/** 记录.
阿昌教你看懂AQS核心流程
阿昌爱Java
01-01 2250
一、预备 Hello!感谢能看菜鸡阿昌的文章 ๑•̀ㅂ•́)و✧ 这几天在学习阳哥的AQS，发现他简直就是艺术品。 这里记录一下AQS的核心执行流程。我们以ReentrantLock为例子，进行突破。 因为AQS涉及到Juc的知识，所以这里需要有一些前置知识如下： ≡ω≡ Juc知识 LockSupport 模版设计模式 重入锁/自旋锁 CAS Unsafe 如果不晓得，请自行去补以上的知识，再看一下的内容 也是建议打开IDEA进行源码调试一起食用极佳 二、前言 1、什么是AQS 字面意思
3.1.4.AQS底层原理分析1
08-04
AQS是一个抽象类，它提供了线程同步的基本机制，包括线程的排队、等待和唤醒。在Java.util.concurrent包中，许多并发工具类如ReentrantLock、Semaphore、CountDownLatch等都基于AQS实现。 AQS的核心概念是基于一个...
java并发编程-AQS和JUC实战
04-29
- **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized` 不同的是，`ReentrantLock` 是一个非内置锁，必须通过显式的调用来获取和释放锁...
【并发编程】简单化理解AQS和ReentrantLock.pdf
最新发布
05-03
并发编程基本概念 - **进程与线程**：进程是操作系统资源分配的基本单位，而线程则是CPU调度的基本单位。每个进程至少包含一个线程，线程间共享进程的资源，但具有独立的栈空间。 - **并行与并发**：并行指多个...
ReentrantLock解析
08-08
NULL 博文链接：https://patrick002.iteye.com/blog/2170391
ReentrantLock详解
weixin_34000916的博客
02-09 975
一 AQS 1 AbstractQueuedSynchronizer AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和相关同步器的框架，它依赖于FIFO的等待队列实现。见AbstractQueuedSynchronizer的描述： Provides a framework for implementing b...
setState 和 compareAndSetState方法作用分析
Ethan Zeng 博客空间
03-13 4236
AQS中有三个protected方法：getState, setState, compareAndSetState。 这三个方法是AQS中提供给自定义同步器来获取state状态的三个基本工具方法，那么setState和compareAndSetState都是用来修改状态的，两者有什么不一样，为什么两者能共存，其各自使用场景分别是什么？ 分析AQS和ReentrantLock的源码可知： co...
java多线程进阶（四）LOCK锁及其原理
jiayibingdong的博客
05-21 2370
java并发包详解（jdk7）
shjhhc的博客
10-18 8017
在此对java并发包做一个大致总结，如有错误，请指正。 juc包的总体结构大致如下 外层框架主要有Lock(ReentrantLock、ReadWriteLock等)、同步器（semaphores等）、阻塞队列（BlockingQueue等）、Executor（线程池）、并发容器（ConcurrentHashMap等）、还有Fork/Join框架； 内层有AQS（AbstractQueue
队列同步器（AQS）详解
void
08-23 1万+
Java自定义同步组件的设计分析、设计思路与源码分析、AQS(AbstractQueuedSynchronizer)结构与原理
并发学习-【转】深入理解并发之CompareAndSet(CAS)
热门推荐
bohu83的博客
04-11 1万+
程老师原文地址：http://flychao88.iteye.com/blog/2269438 原文如下： 一、CAS简介 CAS：Compare and Swap, 翻译成比较并交换。 java.util.concurrent包中借助CAS实现了区别于synchronouse同步锁的一种乐观锁，使用这些类在多核CPU的机器上会有比较好的性能. CAS有3个操作数，内存值V，旧的预期...
一个简单的Java单例示例谈谈并发
程序猿开发日志【学习永无止境】
05-11 4180
一个简单的单例示例 单例模式可能是大家经常接触和使用的一个设计模式，你可能会这么写 public class UnsafeLazyInitiallization { private static UnsafeLazyInitiallization instance; private UnsafeLazyInitiallization() { } pub
深入 Java Lock 锁
Java笔记虾
12-08 438
点击上方“后端技术精选”，选择“置顶公众号”技术文章第一时间送达！作者：超大只乌龟segmentfault.com/a/1190000020806586这篇文章讲的是 Java 的 Lo...
王雷深度剖析AQS原理：Lock实现与应用详解
文档首先介绍了AQS的基本概念，它是一个抽象类，提供了一个First-In-First-Out (FIFO)队列，为各种同步机制如互斥锁（如ReentrantLock）、信号量（CountDownLatch）等提供了基础。 AQS的重要性在于其高效且灵活的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值