并发编程-wait和sleep

最新推荐文章于 2024-04-17 10:43:08 发布
最新推荐文章于 2024-04-17 10:43:08 发布
阅读量446 收藏 1
点赞数
分类专栏： java 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yibailiheng/article/details/113717815
版权

并发编程之wait和sleep的区别

目录

并发编程之wait和sleep的区别

一、区别

二、代码验证sleep

三、代码验证wait

一、区别

相同点：线程的状态相同，都是阻塞状态

不同点：

  1. wait是Object的状态，任何对象都可以调用；sleep时Thread的静态方法。
  2. wait必须配合synchronized关键字一起使用；如果一个对象没有获取到锁尝试直接调用wait会发生异常；sleep则不需要。
  3. wait可以通过notify主动叫醒，sleep只能通过打断主动叫醒。
  4. wait会释放锁，sleep在阻塞的阶段是不会释放锁的。

二、代码验证sleep

场景：多线程情况下，假设某个线程拿到锁了，但是它需要满足某个条件，才能执行，如果使用sleep，会导致在没有满足情况的条件下一直持有锁，别的线程也拿不到

/**
*/
@Slf4j(topic = "liheng")
public class TestWait1 {
    static final Object pc = new Object();
    static boolean isPrettyGril = false; // 有没有女人

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (pc) {
                log.debug("有没有女人[{}]", isPrettyGril);
                if (!isPrettyGril) {
                    log.debug("没有女人！等女人，等5秒;别人也不能干活");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("等了5秒 有没有女人？[{}]", isPrettyGril);
                if (isPrettyGril) {
                    log.debug("------男女搭配干活不累；啪啪啪写完了代码");
                }else{
                    log.debug("------下班回家----");
                }
            }
        }, "jack").start();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (pc) {
                    log.debug("我们10个屌丝工作了");
                }
            }, "其它人").start();
        }

        Thread.sleep(1000);
        new Thread(() -> {
//            synchronized (pc) {
                isPrettyGril = true;
                log.debug("桥本有菜来了");
//            }
        }, "boss").start();
    }
}
/**
-------------------------打印结果----------------------
16:02:28.679 [jack] DEBUG liheng - 有没有女人[false]
16:02:28.682 [jack] DEBUG liheng - 没有女人！等女人，等5秒;别人也不能干活
16:02:29.684 [boss] DEBUG liheng - 桥本有菜来了
16:02:33.685 [jack] DEBUG liheng - 等了5秒 有没有女人？[true]
16:02:33.685 [jack] DEBUG liheng - ------男女搭配干活不累；啪啪啪写完了代码
16:02:33.685 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.685 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.686 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.686 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.686 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.687 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.687 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.687 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.687 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:02:33.688 [其它人] DEBUG liheng - 我们10个屌丝工作了

Process finished with exit code 0

结果分析：jack比较牛逼，需要女人才能干活。jack线程拿到锁，看看是否有女人，没有女人false，没有女人等到五秒钟，这时别人也不能干活。主线程继续执行，这时候有女人了，桥本有菜来了。五秒到了jack再看了一下有没有女人，发现有女人了，然后开始敲代码干活。干完活之后，其他十个屌丝拿到锁，也干活了。

*/



/**
上面代码如果打开注释
*/
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        synchronized (pc) {
            log.debug("我们10个屌丝工作了");
        }
   }, "其它人").start();
}
/**
-----------------------打印结果---------------------
16:22:27.726 [jack] DEBUG liheng - 有没有女人[false]
16:22:27.730 [jack] DEBUG liheng - 没有女人！等女人，等5秒;别人也不能干活
16:22:32.731 [jack] DEBUG liheng - 等了5秒 有没有女人？[false]
16:22:32.732 [jack] DEBUG liheng - ------下班回家----
16:22:32.732 [boss] DEBUG liheng - 桥本有菜来了
16:22:32.732 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.733 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.733 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.733 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.733 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.733 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.734 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.734 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.734 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:22:32.734 [其它人] DEBUG liheng - 我们10个屌丝工作了


结果分析：jack比较牛逼，需要女人才能干活。jack线程拿到锁，看看是否有女人，没有女人false，没有女人等到五秒钟，这时别人也不能干活。主线程继续执行，这时候boss线程有女人但是它拿不到锁，给jack送不进去。等了5秒钟jack发现没有女人，下班回家了。这时候boss线程拿到了锁，将桥本有菜送了进去，释放锁，但是jack已经走了。其他十个屌丝拿到锁，开始干活。
*/

三、代码验证wait

场景1：多线程情况下，假设某个线程拿到锁了，但是它需要满足某个条件，才能执行，如果使用wait，会释放锁

@Slf4j(topic = "liheng")
public class TestWait2 {
    static final Object pc = new Object();
    static boolean isPrettyGril = false; // 女人

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (pc) {
                log.debug("有没有女人[{}]", isPrettyGril);
                if (!isPrettyGril) {
                    log.debug("没有女人！等女人");
                    try {
                        pc.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("老板喊我了 有没有女人？[{}]", isPrettyGril);
                if (isPrettyGril) {
                    log.debug("---男女搭配干活不累；啪啪啪写完了代码");
                }else{
                    log.debug("下班回家");
                }
            }
        }, "jack").start();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (pc) {
                    log.debug( "我们10个屌丝工作了");
                }
            }, "其它人").start();
        }

        Thread.sleep(1000);
        new Thread(() -> {
            synchronized (pc) {
                isPrettyGril = true;
                log.debug("桥本有菜来了");
                pc.notify();
            }
        }, "boss").start();
    }
}
/**
------------------------打印结果-------------------
16:33:00.051 [jack] DEBUG liheng - 有没有女人[false]
16:33:00.054 [jack] DEBUG liheng - 没有女人！等女人
16:33:00.054 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.054 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.054 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.054 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.055 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.055 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.055 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.055 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.055 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:00.055 [其它人] DEBUG liheng - 我们10个屌丝工作了
16:33:01.051 [boss] DEBUG liheng - 桥本有菜来了
16:33:01.052 [jack] DEBUG liheng - 老板喊我了 有没有女人？[true]
16:33:01.052 [jack] DEBUG liheng - ---男女搭配干活不累；啪啪啪写完了代码

结果分析:jack比较牛逼，需要女人才能干活。jack线程拿到锁，看看是否有女人，没有女人false，开始等待老板给分配女人（wait等待），释放了办公室的钥匙，其他是个屌丝拿到锁开始干活，干完活释放锁。老板线程拿到锁，带来了桥本有菜，把jack唤醒。jack看有没有女人，发现桥本有菜来了，开始干活敲代码。
*/
 

场景2: 多线程情况下，假设有多个线程执行需要满足某个条件，才能执行。（jack线程需要girl，rose线程需要money）

@Slf4j(topic = "liheng")
public class TestWait3 {
    static final Object pc = new Object();
    static boolean isPrettyGril = false; // 女人
    static boolean isMoney = false;//工资

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (pc) {
                log.debug("有没有女人[{}]", isPrettyGril);
                if (!isPrettyGril) {
                    log.debug("没有女人！等女人");
                    try {
                        pc.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("老板喊我了 有没有女人？[{}]", isPrettyGril);
                if (isPrettyGril) {
                    log.debug("男女搭配干活不累；啪啪啪写完了代码");
                }else {
                    log.debug("不干了---下班回家--------");
                }
            }
        }, "jack").start();



        new Thread(() -> {
            synchronized (pc) {
                log.debug("有没有工资[{}]", isMoney);
                if (!isMoney) {
                    log.debug("没有工资！等发工资");
                    try {
                        pc.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("老板喊我了 有没有发工资？[{}]", isMoney);
                if (isMoney) {
                    log.debug("-----卧槽好多钱；啪啪啪写完了代码");
                }else {
                    log.debug("约会去了");
                }
            }
        }, "rose").start();


        Thread.sleep(1000);
        new Thread(() -> {
            synchronized (pc) {
                isMoney = true;
                log.debug("发工资了---");
                pc.notify();
            }
        }, "boss").start();
    }
}
/**
--------------------结果打印-----------------
16:49:37.056 [jack] DEBUG liheng - 有没有女人[false]
16:49:37.058 [jack] DEBUG liheng - 没有女人！等女人
16:49:37.058 [rose] DEBUG liheng - 有没有工资[false]
16:49:37.059 [rose] DEBUG liheng - 没有工资！等发工资
16:49:38.057 [boss] DEBUG liheng - 发工资了---
16:49:38.058 [jack] DEBUG liheng - 老板喊我了 有没有女人？[false]
16:49:38.058 [jack] DEBUG liheng - 不干了---下班回家--------
结果分析：jack线程执行，看是否有女人，没有女人等等待女人（wait），rose线程执行，看有没有工资，没有工资没有工资等工资（wait），boss线程拿到锁，发了工资，随机唤醒了jack线程。jack看到没有女人，不干了下班回家。这时候rose线程还在等待被唤醒。



问题1：notify随机唤醒了jack线程，但是boss线程带来了money，理论说执行rose线程才是对的。那是因为notify时随机唤醒的。

问题1解决：使用notifyAll()唤醒，jack和roes线程都会被唤醒。打印结果如下：

16:58:19.881 [jack] DEBUG liheng - 有没有女人[false]
16:58:19.883 [jack] DEBUG liheng - 没有女人！等女人
16:58:19.883 [rose] DEBUG liheng - 有没有工资[false]
16:58:19.883 [rose] DEBUG liheng - 没有工资！等发工资
16:58:20.881 [boss] DEBUG liheng - 发工资了---
16:58:20.881 [rose] DEBUG liheng - 老板喊我了 有没有发工资？[true]
16:58:20.881 [rose] DEBUG liheng - -----卧槽好多钱；啪啪啪写完了代码
16:58:20.881 [jack] DEBUG liheng - 老板喊我了 有没有女人？[false]
16:58:20.881 [jack] DEBUG liheng - 不干了---下班回家--------

问题2:在使用notifyAll()唤醒的时候，jack和rose线程都被唤醒了，但是jack条件不满足，下班回家了，实际来说，jack应该一直等待有女人后敲完代码，才算正确。
*/

场景3:解决上面场景2中的的问题2

@Slf4j(topic = "liheng")
public class TestWait5 {
    static final Object pc = new Object();
    static boolean isPrettyGril = false; // 女人
    static boolean isMoney = false;//工资

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (pc) {
                log.debug("有没有女人[{}]", isPrettyGril);
                while (!isPrettyGril) {
                    log.debug("没有女人！等女人");
                    try {
                        pc.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("老板喊我了 有没有女人？[{}]", isPrettyGril);
                if (isPrettyGril) {
                    log.debug("男女搭配干活不累；啪啪啪写完了代码");
                }else {
                    log.debug("不干了---下班回家--------");
                }
            }
        }, "jack").start();



        new Thread(() -> {
            synchronized (pc) {
                log.debug("有没有工资[{}]", isMoney);
                while (!isMoney) {
                    log.debug("没有工资！等发工资");
                    try {
                        pc.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("老板喊我了 有没有发工资？[{}]", isMoney);
                if (isMoney) {
                    log.debug("-----卧槽好多钱；啪啪啪写完了代码");
                }
            }
        }, "rose").start();

        Thread.sleep(1000);
        new Thread(() -> {
            synchronized (pc) {
                isMoney = true;
                log.debug("发工资了---");
                pc.notifyAll();
            }
        }, "boss").start();
    }
}
/**
------------------打印结果-----------------
17:03:48.605 [jack] DEBUG liheng - 有没有女人[false]
17:03:48.608 [jack] DEBUG liheng - 没有女人！等女人
17:03:48.608 [rose] DEBUG liheng - 有没有工资[false]
17:03:48.608 [rose] DEBUG liheng - 没有工资！等发工资
17:03:49.604 [boss] DEBUG liheng - 发工资了---
17:03:49.605 [rose] DEBUG liheng - 老板喊我了 有没有发工资？[true]
17:03:49.605 [rose] DEBUG liheng - -----卧槽好多钱；啪啪啪写完了代码
17:03:49.605 [jack] DEBUG liheng - 没有女人！等女人

结果分析：使用了while死循环，解决问题2，jack线程一直在等待女人，并没有回家。
*/
  
notifyAll()的经典使用模

synchronized (lock) {
    while (condition) {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // todo 业务代码
}

 

 

 

 

 

 

 

 

 

 

半路笙歌
关注
专栏目录
JAVA 并发编程之九：sleep()和wait() 概念 + 区别 + 应用场景
caobaokang的专栏
04-09 1945
sleep和wait到底什么区别 其实这个问题应该这么问——sleep和wait有什么相同点。因为这两个方法除了都能让当前线程暂停执行完，几乎没有其它相同点。 wait方法是Object类的方法，这意味着所有的Java类都可以调用该方法。 sleep方法是Thread类的静态方法。 wait wait是在当前线程持有wait对象锁的情况下，暂时放弃锁，并让出CPU资源，并积极等待其...
【go从入门到精通】精通并发编程-WaitGroup
最新发布
网易搬砖选手
05-21 469
Go 的 goroutine、通道和互斥体使得开发复杂的并发系统变得很容易。大多数问题都可以使用这三种机制来解决。正如我们前面提到的这篇文章，实际上协程是和很多知识点串起来的 , 并不是孤立的，因此在之前的这篇文章里，我将协程和channel，WaitGroup等知识点进行了综合，这篇文章又拆分来分享给大家。
sleep，wait的区别，尤其是在使用场景上的区别
浩浩的代码花园
08-15 1475
sleep，wait方法的对比 wait sleep 同步 只能在同步上下文中调用wait方法，否则或抛出IllegalMonitorStateException异常 不需要在同步方法或同步块中调用 作用对象 wait方法定义在Object类中，作用于对象本身 sleep方法定义在java.lang.Thread中，作用于当前线程 释放锁资源 是 否 唤醒条件 其他线程调用对象的notify()或者notif...
Java并发编程:Java Thread 的 sleep() 和 wait() 的区别
05-22 93
Java并发编程:Java Thread 的 sleep() 和 wait() 的区别 1. start 和 run 方法解释：　 1） start：　　用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕...
并发编程--sleep()、wait()的区别
qq_42576040的博客
02-27 389
区别： 一、所属类 sleep()方法是属于Thread类的方法 wait()方法是属于Object类的方法 二、sleep()和wait()方法实现阻塞的方式不一样 sleep()方法通过设置“睡眠时间”，以超时等待的方式，来实现线程阻塞。睡眠时间到了，线程才会进入就绪状态，等待执行 wait()方法不需要设置时间，一直处于等待状态，只有当调用notify方法才会进入就绪状态，等待执...
java并发编程：wait和sleep的区别
River的博客
06-04 181
1：wait（）可以指定时间也可以不指定时间，sleep必须指定时间2：在同步中时，对CPU的执行权和锁的处理不同：wait()释放CPU的执行权，释放锁；sleep()释放CPU的执行权，但是不释放锁...
Java并发编程---Thread类
10-30
### Java并发编程——Thread类详解 #### 一、线程的状态 在Java并发编程中，了解线程的各种状态对于理解并正确使用`Thread`类至关重要。一个线程在其生命周期中可能会经历以下几种状态： 1. **创建(new)**：当一...
C#中sleep和wait的区别分析
09-03
理解 `Sleep` 和 `Wait` 的区别对于编写高效的并发代码至关重要。在设计多线程程序时，应根据需求选择合适的方法，以确保线程间能正确地交互和同步，避免出现死锁、饥饿等并发问题。同时，合理使用这两个方法可以...
Java并发编程--基础进阶高级（完结）
m0_67322837的博客
03-15 7277
Java并发编程--基础进阶高级完整笔记。 这都不知道是第几次刷狂神的JUC并发编程了，从第一次的迷茫到现在比较清晰，算是个大进步了，之前JUC笔记不见了，重新做一套笔记。 目录 :fire:1.多线程--基础内容 :fire:2.八锁现象(synchronized、static) 2.static synchronized :fire:3.Java集合--安全性 :fire:4.高并发--辅助类 :fire:5.读写锁(ReadWriteLock) 1.集合--队列（阻...
java中wait的场景,备战金三银四：Java中sleep方法和wait方法的区别
weixin_29268267的博客
03-12 407
来自不同的类sleep(long millis)来自Thread类，和wait()来自Object类。sleep(long millis)是Thread类的静态方法，可接受一个long型入参，意为等待的毫秒数。调用该方法的线程此时会让出CPU时间片，线程等待指定时间后进入可运行状态重新参与CPU的竞争。举个例子：在A线程里调用了B线程的sleep()方法，实际上还是A线程执行sleep()，即进入...
Java 并发之 wait 和 sleep 区别
嗯嗯嗯的博客
08-06 102
wait 和 sleep 到底有什么区别 sleep 方法存在于 Thread类中，而 wait 方法存在于Object类中 sleep 在调用的时候不会去释放对象的锁，wait 会释放对象锁，这也是为什么 wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，因为在调用wait的时候会释放锁，所以必须得先获得锁，那么获取对象锁的方式有哪些呢？ synchronized 关键字 修饰静态方法 synchronized 关键字 修饰实例方法 synchronized 关键字
sleep的使用案例
leo的博客
02-18 465
有其他团队反应，一个四核的方案在应用跑起来的时候，发现cpu的“负载”很高，使用top命令发现有的内核进程百分比很高。 其中[]框起来的是内核线程，其余是用户态线程 NOTE：首先科普，所谓top命令测出的”负载”即百分比并不是真正某个线程或是进程占用cpu的程度，它的算法是去统计当前任务列表中的进程占用cpu的时间，然后去统计一下。 一般我们认为top就会反映真实的cpu的占用情况，其实并...
android wait和sleep区别,Android Sleep和Wait区别
weixin_39638929的博客
05-31 1945
1、这两个方法来自不同的类，sleep来自Thread类，wait 来自Object类。sleep是Thread的静态类方法，谁调用的谁去睡觉，即使是在a线程离调用了b的sleep方法，实际上还是a 去睡觉，要让b去睡觉要在b的代码中调用sleep.2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使其他线程可以使用同步控制块或者方法。sleep不出让系统资源；wait是进入线程等待池...
简单描述Android wait() sleep()区别
awsqsh的专栏
08-01 4415
wait() 属于object类 使用时必须锁定对象。syncronized wait时锁是放开的。   sleep() 属于Thread 类 睡着了也抱着锁不放。
Android面试题——多线程，同步的实现，wait和sleep的不同
tang_js的博客
04-24 1598
多线程是操作系统的重要部分，可以提高应用程序的效率，将耗时操作放在工作线程可以有效提高用户体验。 多线程有两种实现方式：分别是继承Thread类和实现Runnable接口。 同步的实现方式有两种：synchronized，wait与notify。 Public static synchronized void test（）{} Public Void test1（）{synchronize
Java多线程：sleep和wait区别及使用场景
laofeifd的专栏
08-27 1541
1. 区别&使用场景 方法 CPU 锁 所属类 作用 使用场景 sleep() 释放 持有 Thread 用于Thread内部时序控制 延迟几秒执行 wait() 释放 释放 Object 与notify成对，用于线程协助 生产者&消费者模式 yield() 释放 释放 Object 初衷是为了提高线程之间的相对进度，防止过度使用CP
sleep和wait的应用
q85647842的博客
10-20 473
在面试中经常性的遇到wait和sleep的区别？ 1.sleep不会释放锁 ，而wait会释放锁 private static final String LOCK = "lock"; public static void main(String[] args) { new Thread(() -> { System.out.println(Thread.currentThread().getName() + "====start");.
wait(1000)与sleep(1000)的区别
梦想不会灭
12-02 1081
sleep和wait的区别： 1、sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用。 2、sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁(即代码要在synchronized中)。 3、它们都可以被interrupted方法中断。 具体来说： Thread.Sleep(1000) 意思是在未来的1000毫秒内本线程不参与...
解析多线程中wait()和sleep()的区别及使用方法
weixin_42279822的博客
04-17 1560
wait()是Object类的方法，而sleep()是Thread类的静态方法。wait()会释放对象的锁，而sleep()不会释放任何资源。wait()使线程进入等待状态，而sleep()使线程进入休眠状态。通过本文的详细解析和示例，读者可以更清晰地理解wait()和sleep()的区别和用法。wait()通常用于线程间的通信和同步，而sleep()用于暂时休眠线程。根据具体需求和场景，选择合适的方法可以更有效地控制线程的执行状态，实现更复杂。
Java并发编程：Sleep与线程安全
"Java编程中的Sleep方法与异步同步并发编程相关知识" 在Java编程中，线程管理和并发控制是核心概念，特别是对于多线程应用程序来说。本资源主要涵盖了五个关键知识点，包括Sleep状态的打断唤醒、异步与同步的区别、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

半路笙歌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值