Java LockSupport学习

已于 2023-12-18 23:59:21 修改
阅读量637 收藏
点赞数 1
分类专栏： java线程 文章标签： java
于 2023-02-17 23:21:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42472027/article/details/129074497
版权 
面试题:
1、LockSupport为什么可以先唤醒线程后阻塞线程?
   因为unpark()获得了一个凭证，之后再调用park()方法，就可以名正言顺的消费凭证，故不会阻塞。
2、LockSupport为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?
   因为凭证的数量最多为1，连续调用两次unpark()和调用一次unpark效果一样，只会增加一个凭证，
而调用两次park()却需要消费两个凭证，证不够，不能放行。

目录

一、概述

1、wait() && notify()

异常1：wait() && notify()，两个方法都去掉同步代码块执行

异常2：将notify放在wait方法前执行，程序无法唤醒，无法执行。

2、Condition中的await()、signal()实现线程等待唤醒

异常1：await() && signal()，两个方法都去掉锁执行

异常2：将signal()放在await方法前执行，程序无法唤醒，无法执行。

3、LockSupport类中的park()阻塞和unpark()唤醒

3.1、park() && park​(Object blocker)：阻塞当前线程/阻塞传入的具体线程

3.2、unpark​(Thread thread)：唤醒处于阻塞状态的指定线程

3.3、park() && unpark​(Thread thread)阻塞唤醒

3.4、先unpark​(Thread thread)后park()方法：先唤醒后阻塞，依旧正常执行

3.5、LockSupport总结

一、概述

    java.util.concurrent.locks下的类LockSupport：用于创建锁和其他同步类的基本线程阻塞原语。

public class LockSupportextends Object

park():阻塞线程

unpark():解除阻塞线程

    LockSupport：是线程等待唤醒机制(wait/notify)的加强版

    让线程等待和唤醒的方法：

方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

方式2：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

方式3：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

1、wait() && notify()

public class LockSupportDemo {

	static Object obj = new Object();

	public static void main(String[] args) {
		new Thread(() -> {
			synchronized (obj) {
				System.out.println(Thread.currentThread().getName() + "\t ---come in");
				try {
					obj.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
			}
		}, "A").start();

		new Thread(() -> {
			synchronized (obj) {
				obj.notify();
				System.out.println(Thread.currentThread().getName() + "\t ---唤醒");
			}
		}, "B").start();
	}

}

正常结果：

A	 ---come in
B	 ---唤醒
A	 ---被唤醒

异常1：wait() && notify()，两个方法都去掉同步代码块执行

public class LockSupportDemo {

	static Object obj = new Object();

	public static void main(String[] args) {
		new Thread(() -> {
			// synchronized (obj) {
			System.out.println(Thread.currentThread().getName() + "\t ---come in");
			try {
				obj.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
			// }
		}, "A").start();

		new Thread(() -> {
			// synchronized (obj) {
			obj.notify();
			System.out.println(Thread.currentThread().getName() + "\t ---唤醒");
			// }
		}, "B").start();
	}
}

异常结果：

A	 ---come in
Exception in thread "A" Exception in thread "B" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at com.lwz.test.LockSupportDemo.lambda$0(LockSupportDemo.java:12)
	at java.lang.Thread.run(Thread.java:748)
java.lang.IllegalMonitorStateException
	at java.lang.Object.notify(Native Method)
	at com.lwz.test.LockSupportDemo.lambda$1(LockSupportDemo.java:22)
	at java.lang.Thread.run(Thread.java:748)

结论：Object类中的wait、notify、notifyAll用于线程等待唤醒的方法，都必须在synchronized内部执行（必须用到关键字synchronized）。

异常2：将notify放在wait方法前执行，程序无法唤醒，无法执行。

import java.util.concurrent.TimeUnit;

public class LockSupportDemo {

	static Object obj = new Object();

	public static void main(String[] args) {
		new Thread(() -> {
            // 暂停3秒线程A
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			synchronized (obj) {
				System.out.println(Thread.currentThread().getName() + "\t ---come in");
				try {
					obj.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
			}
		}, "A").start();

		new Thread(() -> {
			synchronized (obj) {
				obj.notify();
				System.out.println(Thread.currentThread().getName() + "\t ---唤醒");
			}
		}, "B").start();
	}

}

结果：

B	 ---唤醒
A	 ---come in

结论：先wait后notify、notifyAll方法，等待中的线程才会被唤醒，否则无法唤醒

wait和notify方法必须要在同步代码块或者方法里面且成对出现使用，先wait后notify才行。

2、Condition中的await()、signal()实现线程等待唤醒

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockSupportDemo {

	static Lock lock = new ReentrantLock();
	static Condition condition = lock.newCondition();

	public static void main(String[] args) {
		new Thread(() -> {
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + "\t --come in");
				try {
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
			} finally {
				lock.unlock();
			}

		}, "A").start();

		new Thread(() -> {
			lock.lock();
			try {
				condition.signal();
				System.out.println(Thread.currentThread().getName() + "\t --唤醒");
			} finally {
				lock.unlock();
			}
		}, "B").start();
	}

}

正常结果：

A	 --come in
B	 --唤醒
A	 ---被唤醒

异常1：await() && signal()，两个方法都去掉锁执行

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockSupportDemo {

	static Lock lock = new ReentrantLock();
	static Condition condition = lock.newCondition();

	public static void main(String[] args) {
		new Thread(() -> {
//			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + "\t --come in");
				try {
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
			} finally {
//				lock.unlock();
			}

		}, "A").start();

		new Thread(() -> {
//			lock.lock();
			try {
				condition.signal();
				System.out.println(Thread.currentThread().getName() + "\t --唤醒");
			} finally {
//				lock.unlock();
			}
		}, "B").start();
	}

}

异常结果：

A	 --come in
Exception in thread "A" Exception in thread "B" java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(AbstractQueuedSynchronizer.java:1723)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2036)
	at com.lwz.test.LockSupportDemo.lambda$0(LockSupportDemo.java:18)
	at java.lang.Thread.run(Thread.java:748)
java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1939)
	at com.lwz.test.LockSupportDemo.lambda$1(LockSupportDemo.java:32)
	at java.lang.Thread.run(Thread.java:748)

异常2：将signal()放在await方法前执行，程序无法唤醒，无法执行。

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

public class LockSupportDemo {

	static Lock lock = new ReentrantLock();
	static Condition condition = lock.newCondition();

	public static void main(String[] args) {
		new Thread(() -> {
			// 暂停3秒线程A
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + "\t --come in");
				try {
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
			} finally {
				lock.unlock();
			}

		}, "A").start();

		new Thread(() -> {
			lock.lock();
			try {
				condition.signal();
				System.out.println(Thread.currentThread().getName() + "\t --唤醒");
			} finally {
				lock.unlock();
			}
		}, "B").start();
	}

}

结果：

B	 --唤醒
A	 --come in

结论：

现象和wait、notify效果是一样的，线程先要获得并持有锁，必须在锁块(synchronized或lock)中

必须要先等待后唤醒，线程才能够被唤醒。

3、LockSupport类中的park()阻塞和unpark()唤醒

LockSupport类通过park()和unpark()方法来实现阻塞和唤醒线程的操作。

static void	park():除非许可证可用，否则禁用当前线程以进行线程调度。
static void	park​(Object blocker):除非许可证可用，否则禁用当前线程以进行线程调度。
static void	unpark​(Thread thread):如果给定线程尚不可用，则为其提供许可。
public class LockSupport
extends Object

Basic thread blocking primitives for creating locks and other synchronization classes. 

This class associates, with each thread that uses it, a permit (in the sense of the 
Semaphore class). A call to park will return immediately if the permit is available, 
consuming it in the process; otherwise it may block. A call to unpark makes the permit 
available, if it was not already available. (Unlike with Semaphores though, permits do 
not accumulate. There is at most one.) 

LockSupport:用于创建锁和其他同步类的基本线程阻塞原语。
LockSupport类使用了一种名为Permit(许可)的概念来做阻塞和唤醒功能，每个线程都有一个许可(Permit),
permit只有两个值1和零，默认是零。
可以把许可看成是一种(0,1)信号量(Semaphore),但与Semaphore不同的是，许可的累加上限是1.

3.1、park() && park​(Object blocker)：阻塞当前线程/阻塞传入的具体线程

调用LockSupport.park();

    public static void park() {
        UNSAFE.park(false, 0L);
    }

permit默认是0，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的
permit设置为1时，park()方法会被唤醒，然后会将permit再次设置为0并返回。

3.2、unpark​(Thread thread)：唤醒处于阻塞状态的指定线程

调用LockSupport.unpark(thread);

    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不
会累加，permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport.park();方法会立即返回。

3.3、park() && unpark​(Thread thread)阻塞唤醒

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo {

	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			System.out.println(Thread.currentThread().getName() + "\t --come in");
			LockSupport.park();// 被阻塞..等待许可证
			System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
		}, "t1");
		t1.start();

		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		Thread t2 = new Thread(() -> {
			LockSupport.unpark(t1);
			System.out.println(Thread.currentThread().getName() + "\t --唤醒");
		}, "t2");
		t2.start();
	}

}

结果：

t1	 --come in
t2	 --唤醒
t1	 ---被唤醒

3.4、先unpark​(Thread thread)后park()方法：先唤醒后阻塞，依旧正常执行

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo {

	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "\t --come in");
			LockSupport.park();// 被阻塞..等待许可证
			System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
		}, "t1");
		t1.start();

		Thread t2 = new Thread(() -> {
			LockSupport.unpark(t1);
			System.out.println(Thread.currentThread().getName() + "\t --唤醒");
		}, "t2");
		t2.start();
	}

}

结果：

t2	 --唤醒
t1	 --come in
t1	 ---被唤醒

3.5、LockSupport总结

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。

LockSupport提供park()和unpark()方法实现阻塞线程和接触线程阻塞的过程

LockSupport和每个使用它的线程都有一个许可证(permit)关联。permit相当于1，0的开关，默认是0，调用依次unpark()就加1变成1，调用一次park()会消费permit，也就是将1变为0，同时park()立即返回。如再次调用park()会变成阻塞(因为permit为零了会阻塞在这里，一直到permit变为1)，这时调用unpark()会把permit置为1.

每个线程都有一个相关的permit，permit最多只有一个，重复调用unpark()也不会积累凭证。

形象的理解

线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。

当调用park()方法时：

        如果有凭证，则会直接消耗掉这个凭证然后正常退出。

        如果无凭证，就必须阻塞等待凭证可用。

而unpark()则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo {

	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			System.out.println(Thread.currentThread().getName() + "\t --come in");
			LockSupport.park();// 被阻塞..等待许可证
			LockSupport.park();// 被阻塞..等待许可证
			System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
		}, "t1");

		t1.start();

		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		Thread t2 = new Thread(() -> {
			LockSupport.unpark(t1);
			LockSupport.unpark(t1);
			System.out.println(Thread.currentThread().getName() + "\t --唤醒");
		}, "t2");

		t2.start();
	}

}

结果：

t1	 --come in
t2	 --唤醒

结论：说明了unpark()只能发放一张许可证对应一个park()方法通行。

Java volatile学习

Java AQS学习

干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！

一个程序员最重要的能力是：写出高质量的代码！！
有道无术，术尚可求也，有术无道，止于术。
无论你是年轻还是年长，所有程序员都需要记住：时刻努力学习新技术，否则就会被时代抛弃！

杀神lwz
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java并发编程—锁机制之LockSupport
wait2023的博客
12-24 230
1 概述 是一个工具类，主要作用就是挂起和唤醒线程，内部是调用了Unsafe的方法来实现的，其组成如下图所示。调用LockSupport类的线程会与该类关联一个许可证，默认情况下该类是不持有该许可证的。 下面对其中的一些主要方法进行介绍 2 挂起线程的方法 2.1 park() 如果调用park()方法的线程已经持有许可证则调用该方法时会立马返回，否则调用该方法的线程会被阻塞挂起。注意因调用park()方法而被阻塞的线程被其他线程中断返回时并不会抛出InterruptedException。.
Java并发编程学习之Unsafe类与LockSupport类源码详析
08-27
《深入解析Java并发编程：Unsafe类与LockSupport类源码剖析》 在Java并发编程领域，Unsafe类和LockSupport类是两个重要的底层工具类，它们提供了低级别的内存操作和线程控制，使得开发者能够实现高效的并发算法和...
java locksupport_Java并发之LockSupport
weixin_29009971的博客
02-16 189
内容导读LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。LockSupport是用来创建锁和其他同步类的基本 线程阻塞 原语。park()和unpark()不会有 Thread.suspend 和 Thread.resume 所可能引发的死锁问题，由于许可的存在，调用 park 的线程和另一个试图将其 unpark 的线程之间...
LockSupport详解
最新发布
落日的博客
07-18 736
LockSupport 是 Java 并发包（java.util.concurrent）中的一个工具类，提供了基本的线程阻塞和唤醒机制。它主要用于实现锁和其他同步类，如AQS、 ReentrantLock、Semaphore、CountDownLatch 等。LockSupport 提供的主要方法是park和unpark，它们分别用于挂起和唤醒线程(会让线程进入WATING状态)。AQS中对线程进行挂起和唤醒操作最终使用的就是和。AQS相关内容可以参考 我的上一篇博客AQS详解。
Java并发编程 之LockSupport
const_
12-08 247
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
java locksupport_Java-LockSupport
weixin_35650041的博客
02-16 81
LockSupport 和 CAS 是 Java 并发包中很多并发工具控制机制的基础，它们底层其实都是依赖 Unsafe 实现。LockSupport 提供 park() 和 unpark() 方法实现阻塞线程和解除线程阻塞。每个使用 LockSupport 的线程都会与一个许可(permit)关联，如果该许可可用，则调用 park() 将会立即返回。如果许可尚不可用，则可以调用 unpark()...
Java LockSupport
这就是快乐嘛
05-26 96
使用： 1.阻塞当前线程(LockSupport.park()) 2.已经唤醒指定被阻塞的线程(LockSupport.unpark(XX线程对象)) 被park()的状态是WAITING 实现原理： 每个线程都有一个许可(permit)，permit只有两个值1和0,默认是0。 1.当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。 2.当调用park()方法，如果当前线程的permit是1，那么将pe
java学习资料-线程
06-16
调用wait()、join()、LockSupport.park()等方法会让线程进入等待（WAITING）状态，或者调用wait(long timeout)、sleep(long)、join(long)等方法会让线程进入定时等待（TIMED_WAITING）状态。最后，当线程执行完毕...
LockSupportTest.java
03-08
LockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习demoLockSupport学习...
JUC学习.docx Java
10-23
`park`和`unpark`是`LockSupport`提供的方法，用于线程的阻塞和唤醒控制。`yield`让当前线程自愿放弃CPU时间片，但并不保证其他线程会被立即调度。`join`等待其他线程结束，`wait`和`notify`是对象监视器（Monitor）...
java技术指南
07-19
对于并发编程，文档详细讨论了java.util.concurrent包下的各种并发工具类和接口，如LockSupport、AbstractQueuedSynchronizer、各种锁的实现（ReentrantLock、ReentrantReadWriteLock、StampedLock等）、并发集合...
java LockSupport
I am not a quitter.
07-05 961
LockSupport类有着wait() ，notify()类似的功能，不过更精准。        LockSupport.park(Thread thread) ，//阻塞 thread        LockSupport.unpark(Thread thread) // 唤醒thread 这两个方法是相对应的，其实这两个方法调用的是 Unsafe中对应的方法，而Unsafe
java LockSupport
Code-lover's Learning Notes
04-23 722
LockSupport介绍LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。 LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程，而且park()和unpark()不会遇到“Thread.suspend 和 Thread.resume所可能引发的死锁”问题。 因为park() 和 unpark()有许可的存在；调用 park() 的
java的LockSupport
fall_hat的博客
03-04 173
LockSupport简介 位于java.util.concurrent.locks包下，线程的阻塞原语，用来阻塞线程和唤醒线程，每个使用LockSupport的线程都会与一个许可关联，如果该许可可用，并且可在线程中使用，则调用park()将会立即返回，否则可能阻塞。如果许可尚不可用，则可以调用 unpark 使其可用。但是注意许可不可重入，也就是说只能调用一次park()方法，否则会一直阻塞。 ...
[JUC] LockSupport 相关原理和使用的学习
goalietang的专栏
07-13 223
一、什么是LockSupport LockSupport是java.util.concurrent.locks包下面的一个类。在java并发包下各种同步组件的底层实现中，LockSupport的身影处处可见。JDK中的定义为用来创建锁和其他同步类的线程阻塞原语。我们可以使用它来阻塞和唤醒线程,功能和wait,notify有些相似,但是LockSupport比起wait,notify功能更强大，也好用的多。 并发组件和并发工具大都是基于AQS来实现的， AQS就是AbstractQueuedSynchro
java中的locksupport_详解Java多线程编程中LockSupport类的线程阻塞用法
weixin_26850469的博客
02-23 420
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程，而且park()和unpark()不会遇到“Thread.suspend 和 Thread.resume所可能引发的死锁”问题。因为park() 和 unpark()有许可的存在；调用 park() 的线程和另一个试图将其 unpark...
Java高并发学习（六）—— LockSupport
JohnnyLin
06-13 273
LockSupport 理论 LockSupport是什么？ LockSupport是Java.util.concurrent.locks包下的一个类。是线程等待唤醒进制的（wait和notify）的改良版。 LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。 LockSupport的park() 和unpark(）作用分别是阻塞线程（相当于Object 的wait()）和解除阻塞线程（相当于Object 的notify()）。 在学习LockSupport之前，我们知道2种让线程等待和唤
LockSupport工具
weixin_34101784的博客
05-06 232
1. LockSupport简介 在之前介绍AQS的底层实现，已经在介绍java中的Lock时，比如ReentrantLock,ReentReadWriteLocks,已经在介绍线程间等待/通知机制使用的Condition时都会调用LockSupport.park()方法和LockSupport.unpark()方法。而这个在同步组件的实现中被频繁使用的LockSupport到底是何方神圣，现在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

杀神lwz

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

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

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

打赏作者

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

抵扣说明：

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

余额充值