多线程（二）

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量54 收藏
点赞数
文章标签： java
原文链接：https://juejin.im/post/5ae1dd61f265da0ba60f82a9
版权

一、ReentrantLock

1、重入锁

/**
 * ReentrantLock
 *  重入锁
 */
package concurrent.t03;

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

public class Test_01 {
	Lock lock = new ReentrantLock();
	
	void m1(){
		try{
			lock.lock(); // 加锁
			for(int i = 0; i < 10; i++){
				TimeUnit.SECONDS.sleep(1);
				System.out.println("m1() method " + i);
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock(); // 解锁
		}
	}
	
	void m2(){
		lock.lock();
		System.out.println("m2() method");
		lock.unlock();
	}
	
	public static void main(String[] args) {
		final Test_01 t = new Test_01();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m1();
			}
		}).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m2();
			}
		}).start();
	}
}
复制代码

结果:

m1() method 0
m1() method 1
m1() method 2
m1() method 3
m1() method 4
m1() method 5
m1() method 6
m1() method 7
m1() method 8
m1() method 9
m2() method
复制代码

2、尝试锁

/**
 * 尝试锁
 */
package concurrent.t03;

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

public class Test_02 {
	Lock lock = new ReentrantLock();
	
	void m1(){
		try{
			lock.lock();
			for(int i = 0; i < 10; i++){
				TimeUnit.SECONDS.sleep(1);
				System.out.println("m1() method " + i);
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	void m2(){
		boolean isLocked = false;
		try{
			// 尝试锁， 如果有锁，无法获取锁标记，返回false。
			// 如果获取锁标记，返回true
			// isLocked = lock.tryLock();
			
			// 阻塞尝试锁，阻塞参数代表的时长，尝试获取锁标记。
			// 如果超时，不等待。直接返回。
			isLocked = lock.tryLock(5, TimeUnit.SECONDS); 
			
			if(isLocked){
				System.out.println("m2() method synchronized");
			}else{
				System.out.println("m2() method unsynchronized");
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			if(isLocked){
				// 尝试锁在解除锁标记的时候，一定要判断是否获取到锁标记。
				// 如果当前线程没有获取到锁标记，会抛出异常。
				lock.unlock();
			}
		}
	}
	
	public static void main(String[] args) {
		final Test_02 t = new Test_02();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m1();
			}
		}).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m2();
			}
		}).start();
	}
}
复制代码

结果：

m1() method 0
m1() method 1
m1() method 2
m1() method 3
m1() method 4
m1() method 5
m2() method unsynchronized
m1() method 6
m1() method 7
m1() method 8
m1() method 9
复制代码

3、尝试打断（lockInterruptibly ）

/**
 * 可打断
 * 
 * 阻塞状态： 包括普通阻塞，等待队列，锁池队列。
 * 普通阻塞： sleep(10000)， 可以被打断。调用thread.interrupt()方法，可以打断阻塞状态，抛出异常。
 * 等待队列： wait()方法被调用，也是一种阻塞状态，只能由notify唤醒。无法打断
 * 锁池队列： 无法获取锁标记。不是所有的锁池队列都可被打断。
 *  使用ReentrantLock的lock方法，获取锁标记的时候，如果需要阻塞等待锁标记，无法被打断。
 *  使用ReentrantLock的lockInterruptibly方法，获取锁标记的时候，如果需要阻塞等待，可以被打断。
 * 
 */
package concurrent.t03;

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

public class Test_03 {
	Lock lock = new ReentrantLock();
	
	void m1(){
		try{
			lock.lock();
			for(int i = 0; i < 5; i++){
				TimeUnit.SECONDS.sleep(1);
				System.out.println("m1() method " + i);
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	void m2(){
		try{
			lock.lockInterruptibly(); // 可尝试打断，阻塞等待锁。可以被其他的线程打断阻塞状态
			System.out.println("m2() method");
		}catch(InterruptedException e){
			System.out.println("m2() method interrupted");
		}finally{
			try{
				lock.unlock();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		final Test_03 t = new Test_03();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m1();
			}
		}).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				t.m2();
			}
		});
		t2.start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t2.interrupt();// 打断线程休眠。非正常结束阻塞状态的线程，都会抛出异常。
	}
}
复制代码

结果：

m1() method 0
m1() method 1
m2() method interrupted
java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(Unknown Source)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(Unknown Source)
	at java.util.concurrent.locks.ReentrantLock.unlock(Unknown Source)
	at concurrent.t03.Test_03.m2(Test_03.java:43)
	at concurrent.t03.Test_03$2.run(Test_03.java:67)
	at java.lang.Thread.run(Unknown Source)
m1() method 2
m1() method 3
m1() method 4
复制代码

4、公平锁

/**
 * 公平锁
 */
package concurrent.t03;

import java.util.concurrent.locks.ReentrantLock;

public class Test_04 {
	
	public static void main(String[] args) {
		TestReentrantlock t = new TestReentrantlock();
		//TestSync t = new TestSync();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
	}
}

class TestReentrantlock extends Thread{
	// 定义一个公平锁
	private static ReentrantLock lock = new ReentrantLock(true);
	public void run(){
		for(int i = 0; i < 5; i++){
			lock.lock();
			try{
				System.out.println(Thread.currentThread().getName() + " get lock");
			}finally{
				lock.unlock();
			}
		}
	}
	
}

class TestSync extends Thread{
	public void run(){
		for(int i = 0; i < 5; i++){
			synchronized (this) {
				System.out.println(Thread.currentThread().getName() + " get lock in TestSync");
			}
		}
	}
}
复制代码

结果：

Thread-2 get lock
Thread-1 get lock
Thread-2 get lock
Thread-1 get lock
Thread-2 get lock
Thread-1 get lock
Thread-2 get lock
Thread-1 get lock
Thread-2 get lock
Thread-1 get lock
复制代码

二、生产者消费者

1)、wait&notify

/**
 * 生产者消费者
 * wait&notify
 * wait/notify都是和while配合应用的。可以避免多线程并发判断逻辑失效问题。
 */
package concurrent.t04;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;

public class TestContainer01<E> {

	private final LinkedList<E> list = new LinkedList<>();
	private final int MAX = 10;
	private int count = 0;
	
	public synchronized int getCount(){
		return count;
	}
	
	public synchronized void put(E e){
		while(list.size() == MAX){
			try {
				this.wait();
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
		}
		
		list.add(e);
		count++;
		this.notifyAll();
	}
	
	public synchronized E get(){
		E e = null;
		while(list.size() == 0){
			try{
				this.wait();
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
		}
		e = list.removeFirst();
		count--;
		this.notifyAll();
		return e;
	}
	
	public static void main(String[] args) {
		final TestContainer01<String> c = new TestContainer01<>();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(int j = 0; j < 5; j++){
						System.out.println(c.get());
					}
				}
			}, "consumer"+i).start();
		}
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for(int i = 0; i < 2; i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(int j = 0; j < 25; j++){
						c.put("container value " + j); 
					}
				}
			}, "producer"+i).start();
		}
	}
	
}
复制代码

结果：

container value 0
container value 5
container value 6
container value 5
container value 6
container value 4
container value 1
container value 3
container value 2
container value 1
container value 0
container value 4
container value 2
container value 3
复制代码

2）、重入锁&条件

/**
 * 生产者消费者
 * 重入锁&条件
 * 条件 - Condition， 为Lock增加条件。当条件满足时，做什么事情，如加锁或解锁。如等待或唤醒
 */
package concurrent.t04;

import java.util.LinkedList;
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 TestContainer02<E> {

	private final LinkedList<E> list = new LinkedList<>();
	private final int MAX = 10;
	private int count = 0;
	
	private Lock lock = new ReentrantLock();
	private Condition producer = lock.newCondition();
	private Condition consumer = lock.newCondition();
	
	public int getCount(){
		return count;
	}
	
	public void put(E e){
		lock.lock();
		try {
			while(list.size() == MAX){
				System.out.println(Thread.currentThread().getName() + " 等待。。。");
				// 进入等待队列。释放锁标记。
				// 借助条件，进入的等待队列。
				producer.await();
			}
			System.out.println(Thread.currentThread().getName() + " put 。。。");
			list.add(e);
			count++;
			// 借助条件，唤醒所有的消费者。
			consumer.signalAll();
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public E get(){
		E e = null;

		lock.lock();
		try {
			while(list.size() == 0){
				System.out.println(Thread.currentThread().getName() + " 等待。。。");
				// 借助条件，消费者进入等待队列
				consumer.await();
			}
			System.out.println(Thread.currentThread().getName() + " get 。。。");
			e = list.removeFirst();
			count--;
			// 借助条件，唤醒所有的生产者
			producer.signalAll();
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		} finally {
			lock.unlock();
		}
		
		return e;
	}
	
	public static void main(String[] args) {
		final TestContainer02<String> c = new TestContainer02<>();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(int j = 0; j < 5; j++){
						System.out.println(c.get());
					}
				}
			}, "consumer"+i).start();
		}
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
		for(int i = 0; i < 2; i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(int j = 0; j < 25; j++){
						c.put("container value " + j); 
					}
				}
			}, "producer"+i).start();
		}
	}
	
}
复制代码

结果：

consumer0 等待。。。
consumer1 等待。。。
consumer2 等待。。。
consumer3 等待。。。
consumer6 等待。。。
consumer5 等待。。。
consumer9 等待。。。
consumer8 等待。。。
consumer4 等待。。。
consumer7 等待。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 等待。。。
producer1 等待。。。
consumer0 get 。。。
container value 0
consumer0 get 。。。
container value 1
consumer0 get 。。。
container value 2
consumer0 get 。。。
container value 3
consumer1 get 。。。
container value 4
consumer1 get 。。。
container value 5
consumer2 get 。。。
container value 6
consumer3 get 。。。
container value 7
consumer3 get 。。。
container value 8
consumer6 get 。。。
container value 9
consumer6 等待。。。
consumer5 等待。。。
consumer9 等待。。。
consumer8 等待。。。
consumer4 等待。。。
consumer7 等待。。。
producer0 put 。。。
producer0 put 。。。
producer1 put 。。。
producer1 put 。。。
consumer0 get 。。。
container value 10
consumer1 get 。。。
container value 11
consumer1 get 。。。
container value 0
consumer1 get 。。。
container value 1
consumer2 等待。。。
consumer3 等待。。。
consumer6 等待。。。
consumer5 等待。。。
consumer9 等待。。。
consumer8 等待。。。
consumer4 等待。。。
consumer7 等待。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 put 。。。
producer0 等待。。。
producer1 等待。。。
consumer2 get 。。。
container value 12
consumer2 get 。。。
container value 13
consumer2 get 。。。
container value 14
consumer2 get 。。。
container value 15
consumer3 get 。。。
container value 16
consumer6 get 。。。
container value 17
consumer6 get 。。。
container value 18
consumer5 get 。。。
container value 19
consumer9 get 。。。
container value 20
consumer9 get 。。。
container value 21
consumer8 等待。。。
consumer4 等待。。。
consumer7 等待。。。
producer0 put 。。。
producer0 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 等待。。。
consumer3 get 。。。
container value 22
consumer6 get 。。。
container value 23
consumer5 get 。。。
container value 2
consumer5 get 。。。
container value 3
consumer5 get 。。。
container value 4
consumer5 get 。。。
container value 5
consumer9 get 。。。
container value 6
consumer8 get 。。。
container value 7
consumer4 get 。。。
container value 8
consumer4 get 。。。
container value 9
consumer7 等待。。。
producer0 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 等待。。。
consumer3 get 。。。
container value 24
consumer6 get 。。。
container value 10
consumer9 get 。。。
container value 11
consumer8 get 。。。
container value 12
consumer8 get 。。。
container value 13
consumer8 get 。。。
container value 14
consumer8 get 。。。
container value 15
consumer4 get 。。。
container value 16
consumer7 get 。。。
container value 17
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
producer1 put 。。。
consumer9 get 。。。
container value 18
consumer4 get 。。。
container value 19
consumer7 get 。。。
container value 20
consumer7 get 。。。
container value 21
consumer7 get 。。。
container value 22
consumer7 get 。。。
container value 23
consumer4 get 。。。
container value 24
复制代码
weixin_34072637
关注
多线程，生产者消费者模式经典讲解，简单易懂2
nameIsHG的博客
11-17 332
本模式以一个经典练习为案例： 使用2种锁机制实现生产者和消费者模式 要求 练习（生产者消费者模式）： 自定义同步容器，容器容量上限为10。可以在多线程中应用，并保证数据线程安全。 使用synchronized同步及wait()和notifyAll() 实现生产者消费者模式 逻辑图描述：   /** * 生产者消费者 * wait&amp;notify * wait/no...
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
c++多线程简单实现
Ember的博客
08-17 6348
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、线程和多线程线程多线程二、c++中的多线程实现1.简介2.具体实现三、代码示例四、问题 一、线程和多线程 线程 线程是操作系统能够进行运算调度的最小单位，被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程 简单来说线程就是调度和分配的基本单位，因此引入多线程的概念自然也就是提高了调度和分配的效率，从而提高了程序的运行效率。多线程的
Java多线程
一个小小的码农
07-17 4506
多线程进程其他相关概念创建线程的两种方式为什么使用start（）方法而不直接使用run（）方法start（）方法底层继承Thread 和 实现Rnnable的区别售票系统SellTicket01类继承Thread实现SellTicket02类实现Runnable接口线程终止基本说明通知方式线程常用方法常用第一组注意事项和细节常用方法第二组案例常用方法第三组用户线程和守护线程线程的生命周期线程同步机制利用同步解决买票超卖问题互斥锁基本介绍注意事项和细节线程死锁释放锁练习题同步方法同步代码块 进程 1、进程是指
python实现多线程
qq_35778860的博客
09-11 6432
本文转载于上面的链接. 文章目录1 线程基本概念1.1 线程是什么？1.2 线程和进程关系？2 Python线程模块3 线程间同步4 线程池4.1 传统多线程问题？4.2 线程池基本原理：5 协程5.2 Send来了6. python 进行并发编程6.1 使用asyncio6.2 使用async/await7 小结 1 线程基本概念 1.1 线程是什么？ 线程是指进程内的一个执行单元...
C# 多线程
05-29 1万+
一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进...
多线程面试题（值得收藏）
热门推荐
tanmomo的博客
08-16 21万+
史上最强多线程面试47题(含答案)，建议收藏 金九银十快到了，即将进入找工作的高峰期，最新整理的最全多线程并发面试47题和答案总结，希望对想进BAT的同学有帮助,由于篇幅较长，建议收藏后细看~ 1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修...
多线程与多进程区别
Gefangen的博客
08-15 3360
至于”数据共享、同步“、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍，只能说：没有明确的选择方法。保证指令原子的指向不被打断，Linux系统提供了一些常用操作的原子指令，，包括原子整数操作和原子位操作，必须为atuomic_t类型的整数（32位的整数，24位数据，8bits的锁）信号的处理是进程中所有线程共享的（注意：如果信号的默认处理是终止该进程那么即是把信号传给某个线程也一样会将进程杀掉）；进程中的所有信息对该进程的所有线程都是共享的；...
nodejs 多线程支持
flytam的博客
01-23 2万+
nodejs在v10.5.0新增了多线程的支持，并且在v11中不需要再加实验特性后缀即可直接使用。 使用起来也是非常简便，核心API就以下几个 从使用流程上来说 1、类似于cluster的多进程模式需要判断当前是否主进程，这边也提供了类似的api。通过isMainThread即可。 const { isMainThread } = require('worker_threads'); ...
c#多线程编程实战（原书第二版）源码
06-21
《C#多线程编程实战（原书第二版）源码》是一本深入探讨C#中多线程技术的专业书籍，其源码提供了丰富的实践示例，帮助读者掌握并发编程的核心概念和技术。在C#中，多线程是实现高性能、响应式应用程序的关键组成部分...
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例),可直接运行
01-31
在.NET框架中，C#语言提供了强大的多线程支持，使得开发者可以充分利用现代多核处理器的优势，实现并行处理和高效能编程。本资源包含六个C#.NET多线程的实例，涵盖了多线程的基本使用到更高级的概念，如线程互斥。...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 53
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Arthas sysenv（查看JVM的环境变量）
刘大猫
09-21 428
Arthas sysenv（查看JVM的环境变量）
智能BI平台项目
2302_79400545的博客
09-22 189
BI商业智能：数据可视化、报表可视化系统。
JDK17新增语法特性
2201_76124988的博客
09-20 801
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 575
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 310
faiss版本 faiss-v1.7.4。
Windows多线程编程指南
**二、多线程概述** 多线程允许程序同时执行多个独立的执行流，每个执行流称为一个线程。线程共享同一进程的内存空间，包括全局变量和静态变量，但拥有各自的调用栈，可以独立执行任务。 **三、Win32 API对多线程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值