第四课 同步锁

最新推荐文章于 2023-03-20 22:36:40 发布
最新推荐文章于 2023-03-20 22:36:40 发布
阅读量106 收藏
点赞数
分类专栏： # 07 高级_JUC 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44782182/article/details/108478096
版权

同步锁

1 同步锁

  • 用于解决多线程安全问题的方式
    • 同步代码块
    • 同步方法
    • 同步锁（Java1.5之后），是一个显式的锁，需要通过lock()方法上锁，必须通过unlock()方法释放锁，为了保证一定执行，一般放在finally代码块中
package JUC;

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

/**
 * 模拟抢票
 * 
 * @author Yorick
 *
 */
public class LockTest {
	public static void main(String[] args) {
		TicketSaler saler = new TicketSaler();
		new Thread(saler, "Windows_1:").start();
		new Thread(saler, "Windows_2:").start();
		new Thread(saler, "Windows_3:").start();
	}
}

class TicketSaler implements Runnable {
	private int ticketNum = 100;
	// 创建锁的实例
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		// 当一个线程启动该方法时上锁
		this.lock.lock();
		try {
			while (this.ticketNum > 0) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + --this.ticketNum);
			}
		} finally {
			// 当一个线程结束抢票过程后，解锁
			this.lock.unlock();
		}
	}
}

2 生产者消费者案例——虚假唤醒

2.1 引入

  • 一个标准的生产者消费者实现：此时生产者消费者均生产消费20次（生产数量等于消费数量）
package JUC;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer,"生产者").start();
		new Thread(consumer,"消费者").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;

	public synchronized void getGoods() {
		if (this.goodsNum >= 10) {
			System.out.println("商品已满！");
			try {
				// 商品数量已满时，生产者线程等待，不再进行生产
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
			// 商品数量不足10件时，唤醒生产者线程进行生产
			this.notifyAll();
		}
	}

	public synchronized void saleGoods() {
		if (this.goodsNum <= 0) {
			System.out.println("缺货！");
			try {
				// 商品数量不足时，消费者线程等待，不再进行消费
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
			// 商品数量充足时，唤醒消费者线程进行消费
			this.notifyAll();
		}
	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}

package JUC;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer, "生产者").start();
		new Thread(consumer, "消费者").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;

	public synchronized void getGoods() {
		if (this.goodsNum >= 1) {
			System.out.println("商品已满！");
			try {
				// 商品数量已满时，生产者线程等待，不再进行生产
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
			// 商品数量不足10件时，唤醒生产者线程进行生产
			this.notifyAll();
		}
	}

	public synchronized void saleGoods() {
		if (this.goodsNum <= 0) {
			System.out.println("缺货！");
			try {
				// 商品数量不足时，消费者线程等待，不再进行消费
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
			// 商品数量充足时，唤醒消费者线程进行消费
			this.notifyAll();
		}
	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}
  • 此时，店员只有一个位置供生产者生产消费者消费，且生产速度比消费速度低（获取执行权后消费的次数会多于生产的次数）
  • 现象：程序无法结束
  • 原因：假设消费者线程中的循环进入最后一次，此时由于生产者较慢，还有两轮循环没有走完，此时消费者要消费，但是没有商品，输出“缺货”后挂起等待（此时在if语句块中）。
  • 解决办法：去掉消费者和生产者的else分支保证每次执行都能唤醒另外一个线程

生产者消费者模式

2.2 虚假唤醒

package JUC;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer, "生产者_1").start();
		new Thread(consumer, "消费者_1").start();

		new Thread(producer, "生产者_2").start();
		new Thread(consumer, "消费者_2").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;

	public synchronized void getGoods() {
		while (this.goodsNum >= 1) {
			System.out.println("商品已满！");
			try {
				// 商品数量已满时，生产者线程等待，不再进行生产
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
		// 商品数量不足10件时，唤醒生产者线程进行生产
		this.notifyAll();
	}

	public synchronized void saleGoods() {
		while (this.goodsNum <= 0) {
			System.out.println("缺货！");
			try {
				// 商品数量不足时，消费者线程等待，不再进行消费
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
		// 商品数量充足时，唤醒消费者线程进行消费
		this.notifyAll();
	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}
  • 保持上边的条件不变，创建多个生产者和消费者的线程
  • 现象：这行结果中出现负值
  • 原因：当有多个生产者消费者线程同时执行的时候，如果两个消费者都访问到了saleGoods()方法，且此时商品数量为0，则两个消费者线程均处于等待的状态，但是生产者一次性只生产一个，所以当两个消费者线程再次启动的时候，一个抢到了产品，另一个抢到了-1号产品，此时就会产生错误。
  • 解决办法：将if结构改成while结构，保证每次wait()执行后再次进行商品数量的判断
  • JDK API原文：

java文档wait()方法

3 Condition线程通讯——生产者消费者模式升级

  • Condition接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个Lock可能与多个Condition对象关联。为了避免兼容性问题，Condition方法的名称与对应的Object版本中的不同。
  • 在Condition对象中，与wait()、notify()和notifyAll()方法对应的分别是await()、signal()和signalAll()。
  • Condition实例实质上被绑定到一个锁上。要为特定Lock实例获得Condition实例，请使用其newCondition()方法。
package JUC;

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

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer, "生产者_1").start();
		new Thread(consumer, "消费者_1").start();

		new Thread(producer, "生产者_2").start();
		new Thread(consumer, "消费者_2").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();

	public void getGoods() {
		lock.lock();
		try {
			while (this.goodsNum >= 1) {
				System.out.println("商品已满！");
				try {
					// 商品数量已满时，生产者线程等待，不再进行生产
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
			// 商品数量不足10件时，唤醒生产者线程进行生产
			condition.signalAll();
		} finally {
			lock.unlock();
		}

	}

	public void saleGoods() {
		lock.lock();
		try {
			while (this.goodsNum <= 0) {
				System.out.println("缺货！");
				try {
					// 商品数量不足时，消费者线程等待，不再进行消费
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
			// 商品数量充足时，唤醒消费者线程进行消费
			condition.signalAll();
		} finally {
			lock.unlock();
		}

	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}

4 线程按序交替

package JUC;

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

/**
 * 编写一个程序，开启3 个线程，这三个线程的ID 分别为A、B、C，每个线程将自己的ID 在屏幕上打印10 遍，要求输出的结果必须按顺序显示。
 * 如：ABCABCABC…… 依次递归
 * 
 * @author Yorick
 *
 */
public class AlternateABC {
	public static void main(String[] args) {
		Alternate alternate = new Alternate();
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					alternate.loopA();
				}
			}
		}, "A").start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					alternate.loopB();
				}
			}
		}, "B").start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					alternate.loopC();
				}
			}
		}, "C").start();
	}
}

class Alternate {
	private int number = 1;
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();

	public void loopA() {
		lock.lock();
		try {
			while (this.number != 1) {
				condition1.await();
			}
			System.out.print(Thread.currentThread().getName());
			this.number = 2;
			condition2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void loopB() {
		lock.lock();
		try {
			while (this.number != 2) {
				condition2.await();
			}
			System.out.print(Thread.currentThread().getName());
			this.number = 3;
			condition3.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void loopC() {
		lock.lock();
		try {
			while (this.number != 3) {
				condition3.await();
			}
			System.out.print(Thread.currentThread().getName());
			this.number = 1;
			condition1.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}
Yorick_Xu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第12课：分布式锁
李熠专用博客_白帽子一枚，人称低危终结者
09-22 213
本达人课讲述的是基于 Spring Cloud 的分布式架构，那么也带来了线程安全问题，比如一个商城系统，下单过程可能由不同的微服务协作完成，在高并发的情况下如果不加锁就会有问题，而传统的加锁方式只针对单一架构，对于分布式架构是不适合的，这时就需要用到分布式锁。 实现分布式锁的方式有很多，本文结合我的实际项目和目前的技术趋势，通过实例实现几种较为流行的分布式锁方案，最后会对不同的方案进行比较。 基...
第四课 C# 基于第三课基础,增加视频图像采集线程.zip
06-02
线程的启动、同步和通信是实现这一功能的关键。 在C#中，你可以利用`BackgroundWorker`组件来执行耗时操作，如视频图像的采集，这样不会影响用户界面的更新。`BackgroundWorker`提供了异步执行任务的能力，并且支持...
第五课 锁
Yorick.Xu的技术进化史
08-13 117
锁1 线程同步2 同步块3 单例设计模式4 死锁——生产者消费者模式4.1 模拟死锁现象4.2 生产者消费者模式（信号灯法）5 任务调度（Timer类） 1 线程同步 由于同一进程的多个线程共享同一片存储空间，会引起访问冲突问题。 /** * 使用锁模拟12306 * * @author Administrator * */ public class ThreadSynchronizedTest { public static void main(String[] args) { //
第四课-java锁的使用
weixin_33816821的博客
08-25 90
为什么80%的码农都做不了架构师？>>> ...
第二课 ConcurrentHashMap锁分段机制
Yorick.Xu的技术进化史
09-08 223
ConcurrentHashMap锁分段机制1 HashTable的弊端2 ConcurrentHashMap锁分段机制 1 HashTable的弊端 传统的HashTable会将哈希表整体锁住，导致原本的并行操作转换成串行化操作，提高了数据的一致性，但是性能很低，由于使用锁的机制，会导致复合操作线程不安全的问题，如：“若不存在则添加”。这种复合操作需要两步操作，首先需要判断是否存在，之后进行添加操作，两个方法均存在锁机制，如果判断是否存在的方法执行权被剥夺，则会产生严重的线程安全问题 2 Concur
java并发编程第五课 并发锁讲解一
fegus的博客
05-26 220
第19讲：你知道哪几种锁？分别有什么特点？ 本课时我们首先会对锁的分类有一个整体的概念，了解锁究竟有哪些分类标准。然后在后续的课程中，会对其中重要的锁进行详细讲解。 锁的 7 大分类 需要首先指出的是，这些多种多样的分类，是评价一个事物的多种标准，比如评价一个城市，标准有人口多少、经济发达与否、城市面积大小等。而一个城市可能同时占据多个标准，以北京而言，人口多，经济发达，同时城市面积还很大。   同理，对于 Java 中的锁而言，一把锁也有可能同时占有多个标准，符合多种分类，比如 Reentran
第五课 线程同步
code34的博客
04-04 372
线程同步 处理多线程问题时,多个线程访问同一个对象﹐并且某些线程还想修改这个对象．这时候我们就需要线程同步﹒线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用由于同一进程的多个线程共享同一块存储空间，在带来方便的同时,也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性,在访问时加入锁机synchronized,当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，使用后释放锁即可.存在以下问题: 一个线程持有锁会导致其他.
java并发编程第六课 并发锁讲解二
fegus的博客
05-26 161
第25讲：读写锁 ReadWriteLock 获取锁有哪些规则？ 在本课时我们主要讲解读写锁 ReadWriteLock 获取锁有哪些规则呢？ 在没有读写锁之前，我们假设使用普通的 ReentrantLock，那么虽然我们保证了线程安全，但是也浪费了一定的资源，因为如果多个读操作同时进行，其实并没有线程安全问题，我们可以允许让多个读操作并行，以便提高程序效率。 但是写操作不是线程安全的，如果多个线程同时写，或者在写的同时进行读操作，便会造成线程安全问题。 我们的读写锁就解决了这样的问题，它设定了一套规则，既
第五课 线程八锁
Yorick.Xu的技术进化史
09-08 77
线程八锁1 线程八锁2 线程八锁的关键 1 线程八锁 问题引入： 判断打印的是“one” 还是 “two” 1 两个普通同步方法，两个线程，标准打印 打印结果 One Two package JUC; /** * 线程八锁：第一锁——两个普通同步方法，两个线程，标准打印 * * @author Yorick * */ public class TestThreadMoniter { public static void main(String[] args) { Numbe
DJ2-4 进程同步（第一节课）
狂放不羁霸的博客
03-20 418
2.4.1 进程同步的基本概念 1. 两种形式的制约关系 2. 临界资源（critical resource） 3. 生产者-消费者问题 4. 临界区（critical section） 5. 同步机制应遵循的规则 2.4.2 硬件同步机制 1. 关中断 2. Test-and-Set 指令 3. Swap 指令 4. 小结
java大厂技术面试第二课 多线程和锁
fegus的博客
05-01 373
第03讲：线程的状态有哪些？它是如何工作的？ 线程（Thread）是并发编程的基础，也是程序执行的最小单元，它依托进程而存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，也因此被称为轻量级的进程。 当然，线程也是面试中常被问到的一个知识点，是程序员必备的基础技能，使用它可以有效地提高程序的整体运行速度。 本课时的面试问题是，线程的状态有哪些？它是如何工作的？ 典型回答 线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread
zookeeper第二节课1
08-08
Zookeeper 中的znode分为四种类型：持久（PERSISTENT）、临时（EPHEMERAL）、持久有序（PERSISTENT_SEQUENTIAL）和临时有序（EPHEMERAL_SEQUENTIAL）。持久znode会在客户端不主动删除的情况下一直存在，而临时znode...
第一课：zookeeper 特性与节点说明1
08-08
【第一课：Zookeeper特性与节点说明1】 Zookeeper是一个高度可靠的分布式协调系统，它主要解决在分布式环境中多个节点之间的协同工作问题。Zookeeper的主要作用包括但不限于服务注册与发现、配置管理、分布式锁、...
湖南大学操作系统实验课第二次节点考核工程（95分）-18级老学姐
03-02
学生可能需要用到信号量、锁或者其他同步原语。 6. **文件系统**：虽然描述中没有明确提及，但保存和加载配置或状态信息可能会用到文件系统接口。 7. **编程语言和工具**：实验可能要求使用C、C++或Python等语言，...
第三课：zookeeper_典型使用场景实践（预习）1
08-03
4. 服务资源超出阀值通知：当服务节点的资源使用超过预设阈值时，Zookeeper可以触发报警机制，通知管理员进行资源调整或问题排查。 在架构设计上，通常会创建一个根节点（如 `/tuling-manger`），并在其下创建子...
VOLTE失败码速查表
07-05
VoLTE语言通话服务时，我们可能会遇到各种失败情况。为了帮助大家快速定位和解决这些问题，我整理了一份详细的VoLTE失败码速查表，并分享给大家。这个速查表的主要功能包括快速诊断问题、提高解决效率、学习和培训以及提升用户体验。速查表列出了常见的VoLTE失败代码及其错误原因，技术人员可以通过查阅速查表迅速了解失败的具体原因，减少诊断时间。每个失败码都有详细的描述和解决建议，技术人员可以根据这些建议，快速采取措施，提高问题解决效率。对于新手工程师和自学者来说，速查表是一个很好的学习工具，通过研究每个失败码的原因和解决方案，可以加深对VoLTE技术的理解。通过快速定位和解决VoLTE问题，可以减少用户的等待时间，提升用户的使用体验和满意度。 使用速查表的方法非常简单。当VoLTE通话失败时，系统返回一个失败码。可以在速查表中找到对应的失败码，查看其描述和可能原因。根据速查表中的描述，分析失败的可能原因，考虑网络状态、设备配置等因素。根据速查表中提供的解决建议，采取相应措施进行处理，如检查网络连接、重启设备等。
数学建模在心理测试理论研究.docx
最新发布
07-06
数学建模心理测试研究
Miniconda安装包，对应Python3.9版本
07-05
Miniconda安装包，对应Python3.9版本
minio win 安装包
07-05
minio win 安装包
python 同步锁
09-20
Python 中的同步锁是一个用于控制多个线程对共享资源进行访问的工具。它可以确保在同一时间只有一个线程可以访问共享资源，避免了多个线程同时修改数据导致的冲突。 在 Python 中，可以使用 threading 模块中的 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值