Java并发编程(12)-AQS及其组件介绍

JAVA并发编程中AQS是什么? /独占方式。尝试获取资源,成功则返回true,失败则返回false。//独占方式。尝试释放资源,成功则返回true,失败则返回false。//共享方式。尝试获取资源。负数表示失败;0表示成功,但没有剩余可用资源;正数表示成功,且有剩余资源。//共享方式。尝试释放资源,成功则返回true,失败则返回false。//该线程是否正在独占资源。只有用到condition才需要去实现它。 阅读详情

一.AQS相关

https://www.cnblogs.com/waterystone/p/4920797.html

1.什么是AQS?

AQS全称AbstactQueueSynchronizer,即队列同步器。它使用int类型作为线程的状态,通过名为CLH的FIFO双向队列来管理等待资源的线程。是JUC包中locks包下所有锁实现的基础。

2.AQS的核心原理是什么?

AQS的核心原理是当线程尝试获取共享资源时,若共享资源空闲,则将该线程作为工作线程,并且将共享资源设置为锁定状态。当共享资源处于锁定状态时,则将该线程添加到CLH队列末尾(通过CAS的方式)。

在这里插入图片描述

3.使用AQS实现一个互斥锁

AQS使用的是模板方法模式,所以我们在自己实现一个互斥锁的时候,只需要重写指定的方法即可:

  • Mutex.java
package cocurrency;

import org.jetbrains.annotations.NotNull;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Mutex implements Lock {
    private static class MyAQS extends AbstractQueuedSynchronizer {
        /*
         * @Author ARong
         * @Description 是否处于占用状态
         * @Date 2019/11/23 8:53 下午
         * @Param
         * @return
         **/
        @Override
        protected boolean isHeldExclusively() {
             return getState() == 1;
        }

        /*
         * @Author ARong
         * @Description 尝试获取锁
         * @Date 2019/11/23 8:52 下午
         * @Param [arg]
         * @return boolean
         **/
        @Override
        protected boolean tryAcquire(int arg) {
            // 状态为0才可获取锁
            if (compareAndSetState(0, 1)) {
                // 使用CAS设置锁状态为1成功,设置锁的所有者
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            } else {
                return false;
            }
        }
        /*
         * @Author ARong
         * @Description 尝试释放锁
         * @Date 2019/11/23 8:52 下午
         * @Param
         * @return
         **/
        @Override
        protected boolean tryRelease(int arg) {
            // 释放锁,将状态设置为0
            if (getState() == 0) {
                throw new IllegalMonitorStateException("当前资源没有被锁定");
            } else {
                // 将当前线程的锁解除
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
        }
        Condition newCondition() {
            return new ConditionObject();
        }
    }


    // 以下操作只需要把AQS的内部类实现类代理操作即可
    private final MyAQS aqs = new MyAQS();
    
    @Override
    public void lock() {
        aqs.acquire(1);
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {
        aqs.acquireInterruptibly(1);
    }
    @Override
    public boolean tryLock() {
        return aqs.tryAcquire(1);
    }
    @Override
    public boolean tryLock(long time, @NotNull TimeUnit unit) throws InterruptedException {
        return aqs.tryAcquireNanos(1, unit.toNanos(time));
    }
    @Override
    public void unlock() {
        aqs.release(1);
    }
    @NotNull
    @Override
    public Condition newCondition() {
        return aqs.newCondition();
    }
}

4.AQS定义了哪两种对资源的共享方式?
1.Exclusive(独占):只有一个线程能够获取到该资源,如ReentrantLock。对于独占锁,又可分为公平锁和非公平锁:
  1. 公平锁:以排队队列中的线程先后顺序为为准,先到先得资源的锁。
  2. 非公平锁:无数排队顺序,谁抢占到了资源就是谁的。
2.Share(共享):可以有多个线程获取到该资源,如Semaphore、CountDownLatch、CyclicBarrier和ReadWriteLock。

二.信号量Semaphore相关

https://blog.youkuaiyun.com/qq_19431333/article/details/70212663

synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源,Semaphore(信号量)可以指定多个线程同时访问某个资源。

1,什么是信号量?

信号量规定了一定数量的许可证,在许可证不够用的情况下,获取许可证就会阻塞直到有可用的许可证;再使用完许可证后,可以释放掉许可证。信号量最大的作用就是限制获取资源的线程数量。

  • 一个信号量的使用Demo
public class SemaphoreDemo {

    // 请求的数量
    private static final int threadCount = 550;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象(如果这里线程池的线程数量给太少的话你会发现执行的很慢)
        ExecutorService threadPool = Executors.newFixedThreadPool(300);
        // 一次只能允许执行的线程数量。
        final Semaphore semaphore = new Semaphore(20);

        for (int i = 0; i < threadCount; i++) {
            final int threadnum = i;
            threadPool.execute(() -> {// Lambda 表达式的运用
                try {
                    semaphore.acquire();// 获取一个许可,所以可运行线程数量为20/1=20
                    test(threadnum);
                    semaphore.release();// 释放一个许可
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            });
        }
        threadPool.shutdown();
        System.out.println("finish");
    }

    public static void test(int threadnum) throws InterruptedException {
        Thread.sleep(1000);// 模拟请求的耗时操作
        System.out.println("threadnum:" + threadnum);
        Thread.sleep(1000);// 模拟请求的耗时操作
    }
}
2. acquire()和tryAcquire()有何不同?

这两个方法都可以用于许可证,不同之处在于acquire在许可证不足的时候会阻塞,而tryAcquire会在许可证不足的时候直接返回false。

3.Semaphore的公平模式和非公平模式了解吗?
1.公平模式

根据acquire的顺序来获取许可证,遵循FIFO。

2.非公平模式

即抢占式获取许可证。这是默认情况。

可在构造信号量时通过构造函数去设置这两种模式:

    // 默认是非公平的
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

三.倒计时器(闭锁)CountDownLatch

1.什么是CountDownLatch

CountDownLatch位于java.util.concurrent下,它的作用是使得规定数量的线程在某个位置等待,在数量满足要求后,会在同一时刻并发执行。

2.CountDownLatch有什么作用
  1. 可以使得某个线程等待其他线程全部执行完毕再执行
  2. 可以用作并发模拟
  3. 死锁检测
3.一个计数器使用的例子:主线程等待其他所有线程执行完毕在执行
public class CountDownLatchDemo {
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                0, // corePoolSize
                Integer.MAX_VALUE, // maxPoolSize
                60L,
                TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>()
        );
        int count = 5;
        CountDownLatch latch = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            threadPoolExecutor.execute(() -> {
                try {
                    run();
                } catch (Exception e) {
                }finally {
                    latch.countDown();
                }
            });
        }
        latch.await();
        threadPoolExecutor.shutdown();
        System.out.println("线程执行完毕");
    }

    private static void run() throws InterruptedException {
        Thread.sleep(1000);
        System.out.println(Thread.currentThread());

    }
}

在这里插入图片描述

4.一个并发测试的例子:将所有的子线程全部阻塞在一个入口,等待主线程统一放行
public static void main(String[] args) throws InterruptedException {
        new CountDownLatchDemo().test2();
    }

    private static int counter = 0;
    private static void run() throws InterruptedException {
        System.out.println(Thread.currentThread() + ":" + (++counter));
    }

    private void test2() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                0, // corePoolSize
                Integer.MAX_VALUE, // maxPoolSize
                60L,
                TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>()
        );
        int count = 50, i = 0;
        CountDownLatch latch = new CountDownLatch(1);
        for (i = 0; i <= count; i++) {
            threadPoolExecutor.execute(() -> {
                try {
                    run();
                } catch (Exception e) {
                }finally {
                    latch.countDown();
                }
            });
        }
        // 所有线程启动完成,统一放行
        while (i == count) {
            latch.countDown();
        }
        threadPoolExecutor.shutdown();
        System.out.println("线程执行完毕");
    }

可以看到执行结果中,counter的值出现了并发冲突:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RkixXxsE-1574526056647)(http://note.youdao.com/yws/res/3892/600DC263B4A74CB99AAE2DAC706F371F)]

这时可以使用原子类AtomicInteger,通过CAS去自增计数器的值(为什么不使用volatile呢?因为volatile虽然能保证多线程读写共享变量的可见性,但修改一个变量并写入毕竟是分为读-改-写这三个过程的,所以仍需要使用CAS来保障)。

private static AtomicInteger counter = new AtomicInteger();
    private static void run() throws InterruptedException {
        // 使用原子类 CAS更新值
        System.out.println(Thread.currentThread() + ":" + counter.incrementAndGet());
    }
5.CountDownLatch的常用方法
1.await() vs wait()

await是CountDownLatch的方法,它的作用是在指定位置阻塞线程,直到闭锁中的计数为0;而wait()是Object类的方法。

2.countDown() vs getCount()

countDown()方法用于为计数器减少计数,而getCount()可以获取到当前的计数值。

四.循环栅栏CyclicBarrier

https://blog.youkuaiyun.com/u010185262/article/details/54692886

1.什么是循环栅栏?

CyclicBarrier和CountDownLatch技术差不多,它们都是为了实现线程的等待以及同时执行,但是CyclicBarrier比CountDownLatch更加复杂,它们之间的不同点有:

  1. CyclicBarrier可以循环使用,当计数达到标准时即全部执行,而CountDownLatch只可使用一次。
  2. CyclicBarrier的实现中,计数器是随着等待的线程数量的增加二增加的,当加到一定值时即全部放行;而CountDownLatch中的计数器是通过countDown一个一个地去减少的,减少到0才全部放行。
2,有什么作用

将大任务划分为小任务完成,然后汇集成大任务,并且可以循环这个过程。

3.具体使用
private static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                0, // corePoolSize
                Integer.MAX_VALUE, // maxPoolSize
                60L,
                TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>()
        );
        int count = 50, i = 0;
        for (i = 0; i <= count; i++) {
            threadPoolExecutor.execute(() -> {
                try {
                    runTask();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
    private static void runTask() throws BrokenBarrierException, InterruptedException {
        System.out.println(Thread.currentThread().getName() + "-Ready");
        cyclicBarrier.await();
        System.out.println(Thread.currentThread().getName() + "-Finished");
    }

从打印结果中可以看到,当等待的任务达到5个时,这5个任务就会立刻开始执行,然后开始下一轮的等待:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fQCWDMka-1574526056647)(http://note.youdao.com/yws/res/3932/55D92A61A79B4BDEB12012D9EB052C48)]

AQS的7个同步组件详解及示例代码 以上是AQS的7个同步组件的详细介绍及示例代码。这些同步组件在多线程开发中起到了重要的作用,可以帮助开发者实现各种复杂的同步机制,确保线程间的安全和顺序执行。通过灵活运用这些同步组件,开发者可以更好地控制并发场景下的线程行为。AQS(AbstractQueuedSynchronizer)是Java中用于构建同步器的基础框架。它提供了一组同步组件,可以帮助开发者实现各种复杂的同步机制。本文将详细介绍AQS的7个同步组件,并提供相应的示例代码。 阅读详情

相关推荐

Java并发编程之AQS

AQS是AbstractQueueSynchronizer是缩写,其意思就是抽象队列同步器。原理就是通过一个FIFO队列维护一个state同步状态值,只需要继承该抽象类重写对应的方法便可实现一套线程同步机制。AQS抽象类在java.util.concurrent.locks包下定义。如上图所示,AQS属于一个抽象类,主要是用来构建锁结构以及同步器的一个抽象类。AQS继承了AbstractOwnableSynchronizer,其作用为设置和获取独占锁的拥有者线程方法。

天天新知 2380

AQS详解【Java多线程必备】

Java AQS介绍、特性、原理以及使用案例

Mr.绵羊的知识星球 1091

【Java并发编程】4. 一文搞定JUC半壁江山 AQS

文章目录AQSAQS了解AQS中模版模式AQS重要方法模板方法独占式获取共享式获取独占式释放共享式释放子类需实现方法独占式获取独占式释放共享式获取共享式释放 AQS AQS了解 在JDK中我们一般用AQS来构建跟实现显示锁,语言层面我们一般用Syn来实现。AQS(AbstractQueuedSynchronizer 抽象队列同步器),在上一文中被广泛使用。比如CountDownLatch,Thre...

sowhat 3740

【并发基础】AQS(Abstract Queued Synchronizer)框架的使用和实现原理详解

Java并发包(JUC)中提供了很多并发工具,这其中,很多我们耳熟能详的并发工具,譬如ReentrangLock、Semaphore,它们的实现都用到了一个共同的基类--AbstractQueuedSynchronizer,简称AQS(抽象队列同步器)。AQS是一个用来构建锁和同步器的框架,使用AQS能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的ReentrantLock,Semaph...

小七的博客 2987

用户消费行为分析(MapReduce实现,Hive分析)

一、题目要求 数据来自CDNow网站的一份用户购买CD明细,本数据集共有 6 万条 左右数据,数据为 CDNow 网站 1997年1月至1998年6月的用户行为 数据

紫烟的博客 3014

C#教程

C# 教程 C# 是一个简单的、现代的、通用的、面向对象的编程语言,它是由微软(Microsoft)开发的。 本教程将告诉您基础的 C# 编程,同时将向您讲解 C# 编程语言相关的各种先进理念。 现在开始学习 C#! C# 在线工具 谁适合阅读本教程? 本教程有助于初学者理解基础的 C# 编程。在学习完本教程后,您将到达一个中级的 C# 编程水平。

zm1_1zm 1万+

详解AQS的7个同步组件

AQS的全称为Abstract Queued Synchronizer,是在J.U.C(java.util.concurrent)下子包中的类。

华为云官方博客 1006

腾讯ACE反作弊系统:内核驱动与AI行为分析如何守护游戏公平

在游戏安全领域,反作弊技术是保障公平竞技环境的核心防线。其基本原理是通过监控系统关键行为,识别并阻断非法的第三方程序干预。从技术实现看,现代反作弊方案普遍采用分层防御架构,结合用户态模块进行应用层检测,并依赖内核态驱动实现底层深度监控,以此构建纵深防御体系。这种技术的核心价值在于,它能有效对抗从简单内存修改到高级驱动级作弊等多种威胁,维护游戏经济系统和玩家体验的完整性。随着作弊手段的演进,行为分析与AI赋能变得至关重要,系统通过机器学习模型分析进程行为序列的异常模式,即使面对未知特征的外挂变种也能进行有效识

weixin_33978578的博客 751

什么是AQS?AQS有什么作用?常见的基于AQS的组件有哪些?

1.什么是AQS AQS队列同步器(AbstractQueuedSynchronizer),是用来构建锁或者其他同步组件的基础框架。 它使用了一个int的成员变量表示同步状态,通过内置的FIFO队列来完成资源获取线程的排队工作。 同步器的主要使用方式是继承,子类通过基础同步器并实现它的抽象方法来管理同步状态,在抽象方法的实现过程中免不了对同步状态进行更改,这时需要使用同步器提供的三个方法(getState()、setState(int newState)和compareAndSetState(int exp

weixin_46248981的博客 4049

Windows11下QGIS 3.34.4安装Geo-SAM插件全流程(附RTX3060 CUDA12.0配置技巧)

本文详细介绍了在Windows 11系统中为QGIS 3.34.4安装和配置Geo-SAM插件的完整流程,特别针对RTX 3060显卡用户提供了CUDA 12.0与PyTorch环境的精准搭建方案。通过预编码与交互式分割两大核心步骤,该插件能显著提升遥感图像半自动标注的效率,降低硬件门槛,是地理信息处理领域融合AI技术的实用指南。

weixin_29089057的博客 297

多智能体强化学习MASAC算法:从原理到PyTorch实战详解

深度强化学习通过智能体与环境的交互试错来学习最优策略,是解决复杂序列决策问题的核心技术。其核心原理在于利用价值函数或策略梯度来最大化累积奖励,在机器人控制、游戏AI等领域展现出巨大技术价值。当面对多个智能体需要协同或竞争的复杂动态环境时,单智能体算法因环境非平稳性而面临挑战,多智能体强化学习应运而生。Multi-Agent Soft Actor-Critic (MASAC) 算法融合了SAC的稳定高效与中心化训练去中心化执行的范式,通过维护中心化Critic网络和独立策略网络,有效解决了多智能体协作中的信用

weixin_30080745的博客 335

什么是AQS及其原理

GitHub:https://github.com/JDawnF 1、AQS简介 AQS全名:AbstractQueuedSynchronizer,是并发容器J.U.C(java.lang.concurrent)下locks包内的一个类。它实现了一个FIFO(FirstIn、FisrtOut先进先出)的队列。底层实现的数据结构是一个双向链表。 Sync queue:同步队列,是一个双向链...

striveb的博客 4万+

OpenClaw 完整命令文档(2026.3.13 最新版)

本文档为OpenClaw 2026.3.13通用版使用指南,包含核心命令大全。主要内容包括:1)基础安装/升级/卸载命令;2)ClawHub扩展安装命令(支持飞书/钉钉/企微等平台连接);3)Skills技能安装命令(实现聊天/搜索/记忆等功能);4)飞书机器人授权与配对命令;5)启动运行与配置检查命令;6)工作区与记忆管理命令;7)插件安全设置命令;8)调试日志命令;9)飞书机器人一键部署简化流程。文档特别强调飞书机器人部署需feishu扩展+对应技能+用户授权的完整配置,所有命令均需在终端执行,安装后需

MKliudan的专栏 1295

Java 并发编程之AQS

AbstractQueuedSynchronizer (AQS) 是 Java 并发编程中的一个核心框架,广泛用于构建锁和其他同步器(如信号量、读写锁等)。它是 java.util.concurrent.locks 包的一部分。AQS 的设计目的是简化并发同步器的实现。理解 AQS 对于深入理解 Java 并发编程非常重要。

微笑听雨 6764

ESP32-IDF开发之旅 基础篇⑨ ESP-IDF的FreeRTOS任务间通信和同步

本文介绍了FreeRTOS任务间通信中的队列机制,重点讲解了队列的创建、发送和接收数据的API使用方法。文章提供了详细的技术说明和示例代码,包括xQueueCreate、xQueueSend、xQueueReceive等核心函数的参数说明和返回值解释。通过一个2生产者+1消费者的实际案例,展示了如何在ESP-IDF环境下使用FreeRTOS队列实现任务间通信。示例中包含了数据发送失败处理和接收数据验证等实用技巧,为开发者提供了可参考的实现模式。

单片机菜鸟哥的博客 430

反卷积通俗详细解析与nn.ConvTranspose2d重要参数解释

反卷积的作用 卷积中padding的几个概念 No Padding Half(Same) Padding Full Padding 反卷积 反卷积中的Padding参数 反卷积的stride参数 反卷积总结 参考资料

iioSnail的博客 2万+

Java并发编程,AQS详解

AQS是Java并发编程中一个不可或缺的工具,它不仅简化了锁的实现过程,还为开发者提供了一个强大的基础架构,使得我们可以轻松地创建各种类型的同步组件。理解AQS的工作原理及其相关的同步原语(如锁、条件变量等),可以帮助我们在编写复杂的并发程序时更加得心应手。需要注意的是,虽然AQS提供了许多便利的功能,但它仍然需要谨慎使用,尤其是在处理复杂的同步逻辑时。此外,随着Java版本的不断更新,越来越多的功能已经被标准化和封装到了更高级别的API中,因此我们应该优先考虑使用这些API来满足

横竖撇折点 2507

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java并发编程——AQS原理解析

AQS原理解析,CountDownLatch, Semaphore和CyclicBarrier 详解

m0_62909831的博客 2164

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

【并发编程】AQS原理

全称是,是阻塞式锁和相关的同步器工具的框架//同步器类@Override@Override@Override //是否持有独占锁=null){有了自定义同步器,很容易复用 AQS ,实现一个功能完备的自定义锁@Override //加锁,不成功进入等待队列等待@Override //加锁,可以被打断@Override //尝试加锁(一次)@Override //尝试加锁(带超时时间)@Override //解锁@Override //创建条件变量。

m0_62645012的博客 2068

JAVA并发编程AQS原理剖析

很多小朋友面试时候,都会被面试官问:说一下AQS原理。面对并发编程基础和面试经验,拉丁解牛专栏采用通俗简洁无废话无八股文方式剖析原理和源码,让天下没有难啃的技术。

拉丁解牛技术专栏 1477

java并发编程 Atomic、CAS和AQS的介绍

/ 自定义信号量类 class CustomSemaphore {// 构造函数,初始化信号量许可数量 public CustomSemaphore(int permits) {} // 获取许可 public void acquire() throws InterruptedException {} // 释放许可 public void release() {

不知道说什么的博客 1101

Java 并发编程AQS基本介绍

why-为什么需要AQS?

July的博客 2996

Java并发编程——AQS组件之信号量(Semaphore)

一、AQS组件——信号量Semaphore 1. 信号量(Semaphore)介绍: 作用:用于保证同一时间并发访问线程的数目。 信号量在操作系统中是很重要的概念,Java并发库里的Semaphore就可以很轻松的完成类似操作系统信号量的控制; Semaphore使用acquire方法和release方法来实现控制; 在数据结构中我们学过链表,链表正常是可以保存无限个节点的,而Semaphore...

zjt980452483的博客 1096

Java并发编程核心:深入解析AQS

一文搞懂AQS

weixin_74047328的博客 925

Java并发编程中的AQS是什么?

if (compareAndSetState(0, 1)) { // CAS尝试获取// 无需CAS,独占模式释放是安全的此实现展示了AQS的模板方法设计:子类只需定义资源获取/释放规则,排队、阻塞等复杂逻辑由AQS父类完成。AbstractQueuedSynchronizer(AQS)作为Java并发编程的基石级框架,其价值不仅体现在提供高性能同步工具,更在于它定义了一套可扩展的同步范式。通过state状态管理和CLH队列的精妙结合,AQS平衡了性能、公平性和灵活性三大核心需求。

qq_74825504的博客 993
上一篇: 剑指Offer(50)-[Array&String]整数中1出现的次数
下一篇: 剑指Offer(51)-[Array&String]把数组排成最小的数
BoringRong
BoringRong 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄9年 2万+粉丝 386原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BoringRong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值