Java多线程（七）：ReentrantLock

最新推荐文章于 2024-09-30 18:05:13 发布
最新推荐文章于 2024-09-30 18:05:13 发布
阅读量118 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30684181/article/details/96940244
本文深入讲解ReentrantLock的使用方法，包括加锁解锁机制、条件变量的运用、公平锁与非公平锁的区别及其实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

加锁和解锁

我们来看下ReentrantLock的基本用法
ThreadDomain35类

public class ThreadDomain35 {

    private Lock lock = new ReentrantLock();

    public void testMethod()
    {
        try
        {
            lock.lock();
            for (int i = 0; i < 2; i++)
            {
                System.out.println("ThreadName = " + Thread.currentThread().getName() + ", i  = " + i);
            }
        }
        finally
        {
            lock.unlock();
        }
    }
}

线程和main方法

public class MyThread35 extends Thread {

    private ThreadDomain35 td;

    public MyThread35(ThreadDomain35 td)
    {
        this.td = td;
    }

    public void run()
    {
        td.testMethod();
    }

    public static void main(String[] args)
    {
        ThreadDomain35 td = new ThreadDomain35();
        MyThread35 mt0 = new MyThread35(td);
        MyThread35 mt1 = new MyThread35(td);
        MyThread35 mt2 = new MyThread35(td);
        mt0.start();
        mt1.start();
        mt2.start();
    }
}

输出结果

ThreadName = Thread-2, i  = 0
ThreadName = Thread-2, i  = 1
ThreadName = Thread-0, i  = 0
ThreadName = Thread-0, i  = 1
ThreadName = Thread-1, i  = 0
ThreadName = Thread-1, i  = 1

一个线程必须执行完才能执行下一个线程，说明ReentrantLock可以加锁。

ReentrantLock持有的对象监视器和synchronized不同

ThreadDomain37类,methodB用synchronized修饰

public class ThreadDomain37 {
    private Lock lock = new ReentrantLock();

    public void methodA()
    {
        try
        {
            lock.lock();
            System.out.println("MethodA begin ThreadName = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("MethodA end ThreadName = " + Thread.currentThread().getName());
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }

    }

    public synchronized void methodB()
    {
        System.out.println("MethodB begin ThreadName = " + Thread.currentThread().getName());
        System.out.println("MethodB begin ThreadName = " + Thread.currentThread().getName());
    }
}

MyThread37_0类

public class MyThread37_0 extends Thread {

    private ThreadDomain37 td;

    public MyThread37_0(ThreadDomain37 td)
    {
        this.td = td;
    }

    public void run()
    {
        td.methodA();
    }
}

MyThread37_1类

public class MyThread37_1 extends Thread {
    private ThreadDomain37 td;

    public MyThread37_1(ThreadDomain37 td)
    {
        this.td = td;
    }

    public void run()
    {
        td.methodB();
    }
}

MyThread37_main方法

public class MyThread37_main {

    public static void main(String[] args)
    {
        ThreadDomain37 td = new ThreadDomain37();
        MyThread37_0 mt0 = new MyThread37_0(td);
        MyThread37_1 mt1 = new MyThread37_1(td);
        mt0.start();
        mt1.start();
    }

}

运行结果如下

MethodA begin ThreadName = Thread-0
MethodB begin ThreadName = Thread-1
MethodB begin ThreadName = Thread-1
MethodA end ThreadName = Thread-0

加了synchronized依然是异步执行，说明ReentrantLock和synchronized持有的对象监视器不同。ReentrantLock需要手动加锁和释放锁。

Condition

synchronized与wait()和nitofy()/notifyAll()方法可以实现等待/唤醒模型，ReentrantLock同样可以，需要借助Condition的await()和signal/signalAll()，await()释放锁。
ThreadDomain38类

public class ThreadDomain38 {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void await()
    {
        try
        {
            lock.lock();
            System.out.println("await时间为：" + System.currentTimeMillis());
            condition.await();
            System.out.println("await等待结束");
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }

    public void signal()
    {
        try
        {
            lock.lock();
            System.out.println("signal时间为：" + System.currentTimeMillis());
            condition.signal();
            System.out.println("signal等待结束");
        }
        finally
        {
            lock.unlock();
        }
    }
}

MyThread38类，线程和main方法

public class MyThread38 extends Thread
{
    private ThreadDomain38 td;

    public MyThread38(ThreadDomain38 td)
    {
        this.td = td;
    }

    public void run()
    {
        td.await();
    }

    public static void main(String[] args) throws Exception
    {
        ThreadDomain38 td = new ThreadDomain38();
        MyThread38 mt = new MyThread38(td);
        mt.start();
        Thread.sleep(3000);
        td.signal();
    }
}

运行结果如下

await时间为：1563505465346
signal时间为：1563505468345
signal等待结束
await等待结束

可以看到，ReentrantLock和Condition实现了等待/通知模型。
一个Lock可以创建多个Condition;
notify()唤醒的线程是随机的，signal()可以有选择性地唤醒。

ReentrantLock中的方法

公平锁和非公平锁
ReentrantLock可以指定公平锁和非公平锁，公平锁根据线程运行的顺序获取锁，非公平锁则通过抢占获得锁，不按线程运行顺序。synchronized是非公平锁。在ReentrantLock(boolean fair)构造函数传入true/false来指定公平锁/非公平锁。
看个例子
ThreadDomain39类和main方法

public class ThreadDomain39 {
    private Lock lock = new ReentrantLock(true);

    public void testMethod()
    {
        try
        {
            lock.lock();
            System.out.println("ThreadName" + Thread.currentThread().getName() + "获得锁");
        }
        finally
        {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws Exception
    {
        final ThreadDomain39 td = new ThreadDomain39();
        Runnable runnable = new Runnable()
        {
            public void run()
            {
                System.out.println("线程" + Thread.currentThread().getName() + "运行了");
                td.testMethod();
            }
        };
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++)
            threads[i] = new Thread(runnable);
        for (int i = 0; i < 5; i++)
            threads[i].start();
    }
}

输出结果如下

线程Thread-0运行了
ThreadNameThread-0获得锁
线程Thread-1运行了
线程Thread-2运行了
ThreadNameThread-1获得锁
线程Thread-3运行了
线程Thread-4运行了
ThreadNameThread-2获得锁
ThreadNameThread-3获得锁
ThreadNameThread-4获得锁

可以看到公平锁获得锁的顺序和线程运行的顺序相同。公平锁尽可能地让线程获取锁的顺序和线程运行顺序保持一致，再执行几次，可能不一致。
ReentrantLock构造函数传入false，输出结果如下：

线程Thread-0运行了
线程Thread-2运行了
线程Thread-4运行了
线程Thread-3运行了
ThreadNameThread-0获得锁
线程Thread-1运行了
ThreadNameThread-1获得锁
ThreadNameThread-2获得锁
ThreadNameThread-4获得锁
ThreadNameThread-3获得锁

非公平锁获得锁的顺序和线程运行的顺序不同

getHoldCount()

获取当前线程调用lock()的次数，一般debug使用。
看个例子

public class ThreadDomain40 {
    private ReentrantLock lock = new ReentrantLock();

    public void testMethod1()
    {
        try
        {
            lock.lock();
            System.out.println("testMethod1 getHoldCount = " + lock.getHoldCount());
            testMethod2();
        }
        finally
        {
            lock.unlock();
        }
    }

    public void testMethod2()
    {
        try
        {
            lock.lock();
            System.out.println("testMethod2 getHoldCount = " + lock.getHoldCount());
        }
        finally
        {
            lock.unlock();
        }
    }



    public static void main(String[] args)
    {
        ThreadDomain40 td = new ThreadDomain40();
        td.testMethod1();
    }


}

输出结果如下

testMethod1 getHoldCount = 1
testMethod2 getHoldCount = 2

可以看到，testMethod1()被调用了一次，testMethod2()被调用了两次，ReentrantLock和synchronized一样，锁都是可重入的。

getQueueLength()和isFair()

getQueueLength()获取等待的线程数量，isFair()判断是否是公平锁。
ThreadDomain41类和main方法,Thread.sleep(2000)使第一个线程之后的线程都来不及启动，Thread.sleep(Integer.MAX_VALUE)使线程无法unlock()。

public class ThreadDomain41 {
    public ReentrantLock lock = new ReentrantLock();

    public void testMethod()
    {
        try
        {
            lock.lock();
            System.out.println("ThreadName = " + Thread.currentThread().getName() + "进入方法！");
            System.out.println("是否公平锁？" + lock.isFair());
            Thread.sleep(Integer.MAX_VALUE);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        final ThreadDomain41 td = new ThreadDomain41();
        Runnable runnable = new Runnable()
        {
            public void run()
            {
                td.testMethod();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++)
            threads[i] = new Thread(runnable);
        for (int i = 0; i < 10; i++)
            threads[i].start();
        Thread.sleep(2000);
        System.out.println("有" + td.lock.getQueueLength() + "个线程正在等待！");
    }
}

输出结果如下

ThreadName = Thread-1进入方法！
是否公平锁？false
有9个线程正在等待！

ReentrantLock默认是非公平锁，只有一个线程lock()，9个线程在等待。

hasQueuedThread()和hasQueuedThreads()

hasQueuedThread(Thread thread)查询指定线程是否在等待锁，hasQueuedThreads()查询是否有线程在等待锁。
看个例子
ThreadDomain41类和main方法，和上面例子类似，Thread.sleep(Integer.MAX_VALUE); 让线程不释放锁，Thread.sleep(2000);让第一个线程之后的线程都无法启动。

public class ThreadDomain42 extends ReentrantLock {
    public void waitMethod()
    {
        try
        {
            lock();
            Thread.sleep(Integer.MAX_VALUE);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        final ThreadDomain42 td = new ThreadDomain42();
        Runnable runnable = new Runnable()
        {
            public void run()
            {
                td.waitMethod();
            }
        };
        Thread t0 = new Thread(runnable);
        t0.start();
        Thread.sleep(500);
        Thread t1 = new Thread(runnable);
        t1.start();
        Thread.sleep(500);
        Thread t2 = new Thread(runnable);
        t2.start();
        Thread.sleep(500);
        System.out.println("t0 is waiting？" + td.hasQueuedThread(t0));
        System.out.println("t1 is waiting？" + td.hasQueuedThread(t1));
        System.out.println("t2 is waiting？" + td.hasQueuedThread(t2));
        System.out.println("Is any thread waiting？" + td.hasQueuedThreads());
    }
}

输出结果如下

t0 is waiting？false
t1 is waiting？true
t2 is waiting？true
Is any thread waiting？true

t0线程获得了锁，t0没有释放锁，导致t1,t2等待锁。

isHeldByCurrentThread()和isLocked()

isHeldByCurrentThread()判断锁是否由当前线程持有，isLocked()判断锁是否由任意线程持有。
请看示例
ThreadDomain43类和main方法

public class ThreadDomain43 extends ReentrantLock {
    public void testMethod()
    {
        try
        {
            lock();
            System.out.println(Thread.currentThread().getName() + "线程持有了锁！");
            System.out.println(Thread.currentThread().getName() + "线程是否持有锁？" +
                    isHeldByCurrentThread());
            System.out.println("是否任意线程持有了锁？" + isLocked());
        } finally
        {
            unlock();
        }
    }

    public void testHoldLock()
    {
        System.out.println(Thread.currentThread().getName() + "线程是否持有锁？" +
                isHeldByCurrentThread());
        System.out.println("是否任意线程持有了锁？" + isLocked());
    }

    public static void main(String[] args)
    {
        final ThreadDomain43 td = new ThreadDomain43();
        Runnable runnable0 = new Runnable()
        {
            public void run()
            {
                td.testMethod();
            }
        };
        Runnable runnable1 = new Runnable()
        {
            public void run()
            {
                td.testHoldLock();
            }
        };
        Thread t0 = new Thread(runnable0);
        Thread t1 = new Thread(runnable1);
        t0.start();
        t1.start();
    }
}

输出结果如下

Thread-0线程持有了锁！
Thread-1线程是否持有锁？false
Thread-0线程是否持有锁？true
是否任意线程持有了锁？true
是否任意线程持有了锁？true

Thread-0线程testMethod方法持有锁，Thread-1线程testHoldLock方法没有lock操作，所以不持有锁。

tryLock()和tryLock(long timeout, TimeUnit unit)

tryLock()有加锁的功能，获得了锁且锁没有被另外一个线程持有，此时返回true，否则返回false，可以有效避免死锁。tryLock(long timeout, TimeUnit unit)表示在给定的时间内获得了锁，锁没有被其他线程持有，且不处于中断状态。返回true,否则返回false；
看个例子

public class MyThread39 {
    public static void main(String[] args) {

        System.out.println("开始");
        final Lock lock = new ReentrantLock();
        new Thread() {
            @Override
            public void run() {
                String tName = Thread.currentThread().getName();
                if (lock.tryLock()) {
                    System.out.println(tName + "获取到锁！");
                } else {
                    System.out.println(tName + "获取不到锁！");
                    return;
                }
                try {
                    for (int i = 0; i < 5; i++) {
                        System.out.println(tName + ":" + i);
                    }
                    Thread.sleep(5000);
                } catch (Exception e) {
                    System.out.println(tName + "出错了！");
                } finally {
                    System.out.println(tName + "释放锁！");
                    lock.unlock();
                }

            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                String tName = Thread.currentThread().getName();

                try {
                    if (lock.tryLock(1,TimeUnit.SECONDS)) {
                        System.out.println(tName + "获取到锁！");
                    } else {
                        System.out.println(tName + "获取不到锁！");
                        return;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                try {
                    for (int i = 0; i < 5; i++) {
                        System.out.println(tName + ":" + i);
                    }

                } catch (Exception e) {
                    System.out.println(tName + "出错");
                } finally {
                    System.out.println(tName + "释放锁！");
                    lock.unlock();
                }
            }
        }.start();

        System.out.println("结束");
    }
}

输出结果如下

开始
Thread-0获取到锁！
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
结束
Thread-1获取不到锁！
Thread-0释放锁！

Thread-0先获得了锁，且sleep了5秒，导致Thread-1获取不到锁，我们给Thread-1的tryLock设置1秒，一秒内获取不到锁就会返回false。
如果Thread.sleep(0)，那么Thread-0和Thread-1都可以获得锁，园友可以自己试下。

深入理解 Java 的锁机制：ReentrantLock 与 synchronized
shrgegrb的博客
03-22 1008
ReentrantLock 和 synchronized 都是 Java 中常用的锁机制，各有其特点和适用场景。ReentrantLock 提供了更强大和灵活的锁控制功能，适合复杂的多线程编程场景；而 synchronized 关键字则更为简单易用，适合简单的同步需求。在实际开发中，应根据具体需求选择合适的锁机制，以确保程序的线程安全和高性能。
并发编程实践五：ReentrantLock
宁静致远
05-14 3770
ReentrantLock是一个可重入的互斥锁，实现了接口Lock，和synchronized相比，它们提供了相同的功能，但ReentrantLock使用更灵活，功能更强大，也更复杂。这篇文章将为你介绍ReentrantLock，以及它的实现机制。 ReentrantLock介绍 通常，ReentrantLock按下面的方式使用： public class ReentrantLockTest
被自己蠢哭了的 Runnable.run()方法
热门推荐
Canon
08-23 2万+
之前一直都是用new Thread().start()方法跑线程，昨天撸代码的时候，想起听哪位大佬和我提过，实现Runnable接口比继承Thread类要好。那就实现接口试下吧，结果出问题了，回想起来，真是被自己蠢哭了。。。 我的代码： public class TestMain1 { public static void main(String[] args) { ...
Java锁——搞懂ReentrantLock
泯灭于众生，高歌于孤夜！
01-24 1584
回答一个问题 在开始本篇文章的内容讲述前，先来回答我一个问题，为什么 JDK 提供一个 synchronized 关键字之后还要提供一个 Lock 锁，这不是多此一举吗？难道 JDK 设计人员都是沙雕吗？ 我听过一句话非常的经典，也是我认为是每个人都应该了解的一句话：你以为的并不是你以为的。明白什么意思么？不明白的话，加我微信我告诉你。 初识 ReentrantLock ReentrantLock 位于 java.util.concurrent.locks 包下，它实现了 Lock 接口和 Serializ
线程状态转换
小鲁蛋的博客
10-13 871
4）当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 RUNNABLE --> TIMED_WAITING，调用 LockSupport.unpark(目标线程)，或调用了线程的 interrupt()，或是等待超时，会让目标线程从 TIMED_WAITING--> RUNNABLE。当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE。
Java多线程深度解析：ReentrantLock互斥锁实战
"Java多线程ReentrantLock互斥锁详解" 在Java多线程编程中，ReentrantLock（可重入锁）是JDK提供的一个高级锁机制，它弥补了synchronized关键字的一些不足，提供了更丰富的锁操作。ReentrantLock在Java并发包`java....
多线程系列：ReentrantLock的小秘密
cc_百川
04-10 1201
扒开Reentrantlock的核心小秘密，了解AQS底层原理，日常你应该掌握的多线程应该的相关问题。
Java多线程编程：深度解析ReentrantLock用法
"Java多线程编程中，互斥锁是一种关键的同步机制，用于确保对共享资源的访问是线程安全的。ReentrantLock作为Java中的互斥锁实现，提供了比synchronized更灵活和强大的功能。本文将深入探讨ReentrantLock的用法及其...
Java中的锁机制：ReentrantLock 和 synchronized
最新发布
swadian2008的博客
09-30 870
所谓锁的升级、降级，就是 JVM 优化 Synchronized 运行的机制，当 JVM 检测到不同的竞争状况时，会自动切换到适合的锁实现，这种切换就是锁的升级、降级。当没有竞争出现时，默认会使用偏斜锁。JVM 会利用 CAS 操作（compare and swap），在对象头上的 Mark Word 部分设置线程 ID，以表示这个对象偏向于当前线程，所以并不涉及真正的互斥锁。这样做的假设是基于在很多应用场景中，大部分对象生命周期中最多会被一个线程锁定，使用偏斜锁可以降低无竞争开销。
java多线程实现runnable_Java多线程实现Runnable方式
weixin_29913535的博客
03-08 281
本文为大家分享了java多线程实现Runnable方式的具体方法，供大家参考，具体内容如下(一)步骤1.定义实现Runnable接口2.覆盖Runnable接口中的run方法，将线程要运行的代码存放在run方法中。3.通过Thread类建立线程对象。4.将Runnable接口的子类对象作为实际http://www.cppcns.com参数传递给Thread类的构造函数。为什么要讲Runnable接...
Java的runnable实现步骤简化版。
yinlong181的博客
05-31 393
Java的runnable实现步骤简化版。
Java Lanmbda表达式练习题
weixin_41712089的博客
11-12 1609
1、Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口（只包含一个抽象方法的接口 ）。 请观察如下代码，并使用Lambda表达式改写，实现相同的效果。 // 使用匿名内部类的方式实现多线程 Runnable runnable1 = new Runnable() { public void run() { ...
03多线程常见锁
技术改变世界
10-25 3344
1公平锁、非公平锁 概念：所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。而非公平锁，则是多个线程抢夺锁，会导致优先级反转或饥饿现象 区别： 公平锁在获取锁时先查看此锁维护的等待队列，为空或者当前线程是等待队列的队列，则直接占有锁，否则插⼊到等待队列，FIFO原则。 非公平锁比较粗鲁，上来直接先尝试占有锁，失败则采⽤公平锁方式。非公平锁的优点是吞吐量比公平锁更大。 synchronized 和 juc.ReentrantLock 默认都是非公平锁。ReentrantLock 在..
java并发- 什么是可重入锁 ReentrantLock
西京刀客
03-11 1305
文章目录什么是ReentrantLock怎么使用相关阿里规范基本使用demodemo1： 简单使用demo2： 公平锁实现参考 什么是ReentrantLock 怎么使用 彻底理解ReentrantLock可重入锁的使用 参考URL: https://zhuanlan.zhihu.com/p/88884729 相关阿里规范 【强制】 在使用阻塞等待获取锁的方式中，必须在 try 代码块之外，并且在加锁方法与 try 代码块之间没有任何可能抛出异常的方法调用，避免加锁成功后，在 finally 中无法解锁。
JVM之Java线程启动流程
爱笑才不是傻帽的博客
09-23 541
一：Java线程介绍 做Java开发或者Android的同学，肯定对Java线程很熟悉。之前在阅读一些JVM相关的书时，了解到Java线程其实是映射到操作系统的内核线程上的，所以Java线程基本上也就是操作系统在进行管理。在Linux中，线程和进程用的是同一个结构体进行描述的，只不过进程拥有自己独立的地址空间，而同一个进程的线程之间是共享资源的。 二：Java线程入口分析 想要启动一个Jav...
Java多线程详解（九）Lock锁的使用
筱寒小记
06-11 1668
Lock（锁） 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当 java.util.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象 ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentranrLock，可
多线程的创建及使用（Thread和Runnable）——java基础
林立可
01-27 575
谈多线程之前，先来了解一些概念： 单核和多核： 学过操作系统我们都知道，操作系统有单处理机系统和多处理机系统之分。单处理机也就只有一核处理器CPU，多处理机也就有多核处理器了，所以它的计算处理性能肯定是强于单核系统的。 并行与并发： 并行就是同一时间处理多条命令，就是一个时间点可以处理多个任务；并发就是同一时间段处理多条命令，虽然微观上分时交替执行，但之间的间隙人们感觉不到，宏观上还是多个命令同时执行。可见，多核系统可以做到程序的并行执行，而单核不可以。 进程与线程： 进程就是一个内存中运行的应用程序，它
Java多线程与并发
胜天半子
02-23 345
一、基础概念 1. 并发级别 并发级别分为阻塞和非阻塞； 非阻塞分为无障碍、无锁、无等待。 1）阻塞：当一个线程进入临界区后，其他线程必须等待。 2）无障碍：一种最弱的非阻塞调度，可自由出入临界区，无竞争时有限步骤完成操作，有竞争时回滚数据。 阻塞与非阻塞的无障碍比较：阻塞类似于悲观锁，它认为一起修改数据有可能把数据修改坏；而非阻塞类似于乐观锁，它任务大家一起修改数据未必会把数据修改坏，当它发现多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值