多线程之任务时限

最新推荐文章于 2022-09-17 15:16:21 发布
最新推荐文章于 2022-09-17 15:16:21 发布
阅读量578 收藏 1
点赞数
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cc907566076/article/details/84973060
版权

有的时候我们希望在一定时间内获取这个任务的结果，如果没有获取到就结束这个任务。这个时候需要对任务的时间做一个限制。

  • Future.get(long timeout, TimeUnit unit)

future.get方法提供了这样的参数，当结果可用时，它将立即返回，如果在指定时限内没有计算出结果，那么将抛出TimeoutException。当任务超时后，future也提供了一定的方法来取消任务，如果任务是可取消的，那么可以提前中止它，避免资源的浪费。

之前的例子稍微改一下，即可：

package com.cc.test.timelimit;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @ClassName: TimeLimitTaskTest 
 * @Description: 在指定时间内获取信息
 * @author CC  
 * @date 2018年12月12日 上午10:00:05 
 * @version V1.0 
 */
public class TimeLimitTaskTest {
	private final static long TIME_BUDGET = 2;//超时时间：5  将此设置为2，可以出现超时异常，程序还在运行，只是这次的统计结果并没有出现了，bingo
	private final static TimeUnit Time_Unit = TimeUnit.SECONDS;//超时单位 秒
	//线程池
	private final static ExecutorService executor = Executors.newCachedThreadPool();
	
	//调度请求，获得返回结果，并进行汇总处理
	public static void main(String[] args) throws Exception {
		final String[] methodStr = new String[] {"WeiXin","ZhiFuBao","WangYin"};
		final String[] serviceStr = new String[] {"TaoBao","JingDong","TianMao"};
		
		//为了方便，我们将请求先初始化完毕
		final List<Request> requestList = new ArrayList<Request>();
		for (int i = 0; i < 20; i++) {
			Request request = new Request();
			request.setMethod(methodStr[(int) (Math.random() * 3)]);
			request.setParam((int) (Math.random() * 300));
			request.setServieName(serviceStr[(int) (Math.random() * 3)]);
			requestList.add(request);
		}
		
		long startTime = System.currentTimeMillis();//开始时间
		
		//累积计算所有请求的总扣款数--计算任务提前开始且每个都是分开的不相互影响
		List<Future<Double>> futureList = new ArrayList<Future<Double>>();
		for (int i = 0; i < requestList.size(); i++) {
			Request request = requestList.get(i);
			Callable<Double> task = new Callable<Double>() {
				@Override
				public Double call() throws Exception {
					return  requestForService(request);
				}
			};
			Future<Double> future = executor.submit(task);
			futureList.add(future);
		}
		
		try {
			BigDecimal sum = BigDecimal.ZERO;//同理  double计算结果不精确
			
			//方法get具有“状态依赖”的内在特性，因而调用者不需要知道任务的状态，此外在任务提交和获得
			//结果中包含的安全发布属性也确保了这个方法是线程安全的。
			//获得结果
			for (int i = 0; i < futureList.size(); i++) {
				//提交任务请求
				/*
				 * 传递给get的timeout参数的计算方法是，将制定时限减去当前时间。这可能会得到负数，但java.util.concurrent中所有与
				 * 时限相关的方法都将负数视为零，因此不需要额外的代码来处理这种情况。
				 */
				double payMent = 0.0;
				try {
					payMent = futureList.get(i).get(TIME_BUDGET, Time_Unit);
				} catch (TimeoutException e) {
					futureList.get(i).cancel(true);//Future.cancel的参数为true表示任务线程可以在运行过程中中断，参见第七章
					throw launderThrowable("任务超时，超时时间：" + TIME_BUDGET + " " + Time_Unit);
				}
				sum = sum.add(new BigDecimal(String.valueOf(payMent)));
			}
			System.out.println("一共扣款了多少钱？" + sum.doubleValue());
		} catch (InterruptedException e) {
			// TODO: 任务调用get的线程在获得结果之前被中断
			//重新设置线程的中断状态
			Thread.currentThread().interrupt();
			System.out.println("任务调用get的线程在获得结果之前被中断！" + e);
		} catch (ExecutionException e) {
			//所有线程结束
			executor.shutdown();
			System.err.println("有任务发生异常，所有任务线程结束！");
			throw launderThrowable(e.getMessage());
		} 

		long endTime = System.currentTimeMillis();//结束时间
		System.out.println("消耗时间：" + (endTime - startTime) + "毫秒！");
	}
	
	//模拟第三方服务
	public static double requestForService(Request request) throws InterruptedException, Exception{
		if(null == request) {
			throw new Exception("请求为空！");
		}
		if(request.getParam() <= 0) {
			throw new Exception("参数小于0，无法进行扣款！" + request);
		}
		
		System.out.println("开始处理请求...");
		
		//为了简便直接返回一个结果即可
		double result = 0.0;
		if("WeiXin".equals(request.getMethod())) {
			System.out.println("微信支付扣3%");
//				result = request.getParam() * 0.03;//double类型计算结果不准确  例如17 * 0.05 返回  扣款数  0.8500000000000001
			result = new BigDecimal(String.valueOf(request.getParam())).multiply(new BigDecimal("0.03")).doubleValue();
		}else {
			System.out.println("其他支付直接扣5%");
			result = new BigDecimal(String.valueOf(request.getParam())).multiply(new BigDecimal("0.05")).doubleValue();
		}
		
		//模拟-使消耗时间长一些
		Thread.sleep(3000);
		System.out.println(request + " 返回扣款结果：" + result);
		return result;
	}
	
	/**
	 * @Title: launderThrowable 
	 * @Description: 任务执行过程中遇到异常，根据包装的ExecutionException重新抛出异常，并打印异常信息
	 * @param @param cause
	 * @param @return   
	 * @return Exception  
	 * @throws
	 * @author CC
	 * @date 2018年12月7日 上午9:36:27
	 * @version V1.0
	 */
	private static Exception launderThrowable(String cause) {
		//抛出
		Exception exception = null;
		if(null == cause) {
			exception = new Exception("任务执行过程中遇到异常！");
		}else {
			exception = new Exception("任务执行过程中遇到异常！" + cause);
		}
		return exception;
	}
}

运行结果：
开始处理请求…
微信支付扣3%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
Exception in thread “main” java.lang.Exception: 任务执行过程中遇到异常！任务超时，超时时间：2 SECONDS
at com.cc.test.timelimit.TimeLimitTaskTest.launderThrowable(TimeLimitTaskTest.java:141)
at com.cc.test.timelimit.TimeLimitTaskTest.main(TimeLimitTaskTest.java:75)
Request [method=ZhiFuBao, servieName=JingDong, param=87] 返回扣款结果：4.35
Request [method=WangYin, servieName=JingDong, param=272] 返回扣款结果：13.6
Request [method=WangYin, servieName=TianMao, param=45] 返回扣款结果：2.25
Request [method=WeiXin, servieName=TianMao, param=239] 返回扣款结果：7.17
Request [method=WangYin, servieName=TianMao, param=29] 返回扣款结果：1.45
Request [method=WangYin, servieName=TianMao, param=171] 返回扣款结果：8.55
Request [method=WeiXin, servieName=TianMao, param=252] 返回扣款结果：7.56
Request [method=WeiXin, servieName=TaoBao, param=127] 返回扣款结果：3.81
Request [method=ZhiFuBao, servieName=TianMao, param=97] 返回扣款结果：4.85
Request [method=WeiXin, servieName=TianMao, param=86] 返回扣款结果：2.58
Request [method=WangYin, servieName=TaoBao, param=4] 返回扣款结果：0.2
Request [method=WangYin, servieName=JingDong, param=52] 返回扣款结果：2.6
Request [method=WeiXin, servieName=JingDong, param=18] 返回扣款结果：0.54
Request [method=WangYin, servieName=JingDong, param=244] 返回扣款结果：12.2
Request [method=ZhiFuBao, servieName=JingDong, param=216] 返回扣款结果：10.8
Request [method=ZhiFuBao, servieName=TianMao, param=279] 返回扣款结果：13.95
Request [method=ZhiFuBao, servieName=TaoBao, param=89] 返回扣款结果：4.45
Request [method=WangYin, servieName=TaoBao, param=297] 返回扣款结果：14.85
Request [method=WangYin, servieName=JingDong, param=236] 返回扣款结果：11.8

  • executor.invokeAll

executor中的invokeAll方法提供了一个更好的实现。
书中描述：
InvokeAll方法的参数为一组任务，并返回一组Future。这两个集合有着相同的结构。InvokeAll按照任务集合中迭代器的顺序将所有的Future添加到返回的集合中，从而使调用者能将各个Future与其表示的Callable关联起来。当所有任务都执行完毕时，或者调用线程被中断时，又或者超过指定时限时，invokeAll将返回。当超过指定时限时，任何还未完成的任务都会被取消。当invokeAll返回后，每个任务要么正常地完成，要么被取消，而客户端代码可以调用get或isCancelled来判断究竟是何种情况。

之前例子改下，如下：

package com.cc.test.timelimit2;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @ClassName: TimeLimitTaskTest 
 * @Description: 在指定时间内获取信息
 * @author CC  
 * @date 2018年12月12日 上午10:00:05 
 * @version V1.0 
 */
public class TimeLimitTaskTest {
	private final static long TIME_BUDGET = 2;//超时时间：5  将此设置为2，可以出现超时异常，程序还在运行，只是这次的统计结果并没有出现了，bingo
	private final static TimeUnit Time_Unit = TimeUnit.SECONDS;//超时单位 秒
	//线程池
	private final static ExecutorService executor = Executors.newCachedThreadPool();
	
	//调度请求，获得返回结果，并进行汇总处理
	public static void main(String[] args) throws Exception {
		final String[] methodStr = new String[] {"WeiXin","ZhiFuBao","WangYin"};
		final String[] serviceStr = new String[] {"TaoBao","JingDong","TianMao"};
		
		//为了方便，我们将请求先初始化完毕
		final List<Request> requestList = new ArrayList<Request>();
		for (int i = 0; i < 20; i++) {
			Request request = new Request();
			request.setMethod(methodStr[(int) (Math.random() * 3)]);
			request.setParam((int) (Math.random() * 300));
			request.setServieName(serviceStr[(int) (Math.random() * 3)]);
			requestList.add(request);
		}
		
		long startTime = System.currentTimeMillis();//开始时间

		//累积计算所有请求的总扣款数--计算任务提前开始且每个都是分开的不相互影响
		List<Callable<Double>> tasks = new ArrayList<Callable<Double>>();//任务集参数
		for (int i = 0; i < requestList.size(); i++) {
			Request request = requestList.get(i);
			Callable<Double> task = new Callable<Double>() {
				@Override
				public Double call() throws Exception {
					return  requestForService(request);
				}
			};
			tasks.add(task);
		}
		
		List<Future<Double>> futures = executor.invokeAll(tasks, TIME_BUDGET, Time_Unit);//执行任务
		
		BigDecimal sum = BigDecimal.ZERO;
		for (int i = 0; i < futures.size(); i++) {
			try {
				//获得结果
				double payMent = futures.get(i).get();
				sum = sum.add(new BigDecimal(String.valueOf(payMent)));
			} catch (InterruptedException e) {
				// TODO: 任务调用get的线程在获得结果之前被中断
				//重新设置线程的中断状态
				Thread.currentThread().interrupt();
				System.out.println("任务调用get的线程在获得结果之前被中断！" + e);
			} catch(CancellationException e) {
				//任务取消发生异常 - 任务超时也进入了这里
				throw launderThrowable("任务超时！" + e.getMessage());
			} catch(Exception e) {
				//其他不可预料异常
				throw launderThrowable("任务发生异常！" + e.getMessage());
			}
		}
		System.out.println("一共扣款了多少钱？" + sum.doubleValue());
		long endTime = System.currentTimeMillis();//结束时间
		System.out.println("消耗时间：" + (endTime - startTime) + "毫秒！");
	}
	
	//模拟第三方服务
	public static double requestForService(Request request) throws InterruptedException, Exception{
		if(null == request) {
			throw new Exception("请求为空！");
		}
		if(request.getParam() <= 0) {
			throw new Exception("参数小于0，无法进行扣款！" + request);
		}
		
		System.out.println("开始处理请求...");
		
		//为了简便直接返回一个结果即可
		double result = 0.0;
		if("WeiXin".equals(request.getMethod())) {
			System.out.println("微信支付扣3%");
//				result = request.getParam() * 0.03;//double类型计算结果不准确  例如17 * 0.05 返回  扣款数  0.8500000000000001
			result = new BigDecimal(String.valueOf(request.getParam())).multiply(new BigDecimal("0.03")).doubleValue();
		}else {
			System.out.println("其他支付直接扣5%");
			result = new BigDecimal(String.valueOf(request.getParam())).multiply(new BigDecimal("0.05")).doubleValue();
		}
		
		//模拟-使消耗时间长一些
		Thread.sleep(3000);
		System.out.println(request + " 返回扣款结果：" + result);
		return result;
	}
	
	/**
	 * @Title: launderThrowable 
	 * @Description: 任务执行过程中遇到异常，根据包装的ExecutionException重新抛出异常，并打印异常信息
	 * @param @param cause
	 * @param @return   
	 * @return Exception  
	 * @throws
	 * @author CC
	 * @date 2018年12月7日 上午9:36:27
	 * @version V1.0
	 */
	private static Exception launderThrowable(String cause) {
		//抛出
		Exception exception = null;
		if(null == cause) {
			exception = new Exception("任务执行过程中遇到异常！");
		}else {
			exception = new Exception("任务执行过程中遇到异常！" + cause);
		}
		return exception;
	}
}

运行结果：
运行结果：
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
其他支付直接扣5%
开始处理请求…
微信支付扣3%
开始处理请求…
微信支付扣3%
开始处理请求…
其他支付直接扣5%
Exception in thread “main” java.lang.Exception: 任务执行过程中遇到异常！任务超时！null
at com.cc.test.timelimit2.TimeLimitTaskTest.launderThrowable(TimeLimitTaskTest.java:130)
at com.cc.test.timelimit2.TimeLimitTaskTest.main(TimeLimitTaskTest.java:74)
（程序还在运行中）

cc-lady
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2.多线程的创建方式
qq_37385585的博客
01-31 238
以下内容全部都来自 bilibili 宋红康老师java基础部分内容P415 ~ P446 小节中 https://www.bilibili.com/video/BV1Kb411W75N?p=415 多线程的创建方式共有 4 种 继承Thread类的方式 实现Runnable接口的方式 实现Callable接口的方式 使用线程池创建 本篇文章讲前面 3 种 1、使用继承Thread类的方式创建多线程 *步骤：* 创建一个继承与Thread类的子类 重写Thread类的run() 方法 ，将想要用子线程
Future获取子线程的执行结果
法毅的博客
06-19 5060
1. Runnable的缺陷 2.Callable 接口 3. Future 类 4.用法1: 线程池的submit方法会回Future对象，6分da
sprngboot使用@Async实现异步调用二：使用Future以及定义超时
胃病的不良少彦
06-10 3389
文章目录1. Tips：什么是Future类型？2. 正常用future的get(long timeout, TimeUnit unit)进行异步调用3. 正常用future的get( )阻塞代码进行异步调用 1. Tips：什么是Future类型？ Future是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果的接口。必要时可以通过get方法获取执行结...
Java程序执行超时——Future接口介绍
颢喆的专栏
01-26 1736
在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实 现，可以来进行异步计算。Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时 间之后，我就便可以从Future那儿取出结果。就相当于下了一张订货
Future和Callable的使用
weixin_40472874的博客
08-02 507
在默认情况下，线程 Thread 对象不具有返回值的功能，如果在需要取得返回值的情况下是极为不方便的，但在 Javal.5 的并发包中可以使用Future和Callable 来使线程具有返回值的功能。 Future和Callable 的介绍 接口 Callable 与线程功能密不可分，但和 Runnable 主要区别为： (1) Callable 接口的 call（方法可以有返回值，而 Runnable 接口的 run()方法没有返回值。 (2)Callable 接口的 call()方法可以声明抛出异常，而
多线程面试59题（含答案）.pdf
01-04
多线程可以让多段逻辑同时工作，充分利用 CPU 的资源，防止阻塞可以防止程序的停止运行，多线程还可以便于建模，分解大任务为小任务，分别建立程序模型。 线程和进程的主要区别在于它们是不同的操作系统资源管理...
Java线程超时监控
07-18
在Java编程中，多线程是并发执行任务的重要方式，然而在实际应用中，我们可能会遇到某些线程执行时间过长或死锁的情况，这可能导致系统资源的浪费甚至整体性能下降。因此，对线程进行超时监控是必要的，以确保程序的...
支持多线程处理器的实时操作系统实现研究 (2009年)
05-18
- **任务调度优化**：通过改进的任务调度算法来优化资源分配，使得多线程任务能够在处理器之间更加高效地运行。 - **并发控制机制**：引入了有效的并发控制机制，以避免因线程间的竞争而产生的死锁或活锁问题。 - **...
ChatApp2:时限4
05-14
在Java编程中，构建这样的应用程序涉及到多个关键知识点，包括网络编程、多线程、数据序列化以及UI设计等。 首先，**网络编程**是ChatApp的基础，它需要利用Socket编程来建立客户端和服务器之间的连接。Java的`java...
java 监听超时_java多线程实现任务超时监听
weixin_30247915的博客
02-12 717
在实际的开发过程当中，会遇到这样的需求：某些功能为了防止系统挂死，需要进行时间控制，超过一定的执行时间，就提示任务执行超时，不再继续执行该任务，从而保证系统健壮性和稳定性。其实仔细想想，我们可以把这样的需求，全部归结为一种“超时控制的业务模型”，建立起自己熟悉的业务模型，以后碰到类似的需求，可以借鉴此方案。若有机会设计或重构系统，在必要的模块中，也可以将该方案作为增强系统稳定性的一个备选方案。方案...
Java并发编程学习8-同步工具类
最新发布
Huazie
09-17 1475
本篇介绍一下Java平台类库下的常用的同步工具类（闭锁、Future、信号量和栅栏）
Java多线程 冰球比赛：每局限时20分钟
m0_62055572的博客
05-20 412
多线程：冰球比赛，三局，每局二十分钟，中场休息十五分钟
Future取消任务
A169388842的博客
06-22 1576
Future取消任务: **通过Future取消那些不再需要结果的任务: //示例: /** * TimedRun * &lt;p/&gt; * Cancelling a task using Future */ public class TimedRun { private static final ExecutorService TASK_EXEC = Execut...
给线程指定超时时间，超时则停止线程
weixin_30515513的博客
12-04 598
1 private String getRecommendCount(BaseInfo baseInfo) throws Exception{ 2 ExecutorService exec = Executors.newCachedThreadPool(); 3 // int timeout = 5; // 访问接口的时间限制 4 S...
ExecutorService等所有线程执行完毕，并设置超时时间
u013232219的博客
04-13 1839
1、工作中遇到的业务处理需要： 例： 生产问题：生产上一个常用的会话接口，此接口内集成了5个外部接口能力（python的，Java的，其中每个接口基本耗时2~3秒），原有会话接口里是依次去调用的， 这就导致用户体验很差，因为2乘5也就是10秒，也就是说会话接口耗时10秒起步； 解决方案：将原来的依次调用，改为多线程异步调用，等所有线程的调用都处理结束后，再去统一处理封装数据，因为多线程异步的原因，一个接口调用耗时2~3秒， 则...
Java并发学习之中断策略
c1776167012的博客
11-22 385
一. 中断策略学习 我们前面学习了任务包含取消策略，同样的，线程应该包含中断策略。 1.中断策略规定线程如何解释某个中断请求：当发现中断请求时，应该做哪些工作（如果需要的话），哪些工作单元对于中断来说是原子操作，以及以多快的速度来响应中断。 2.最合理的中断策略是某种形式的线程级取消操作或者服务级取消操作：尽快退出，在必要时清理，通知某个所有者该线程已经退出。 3.除此之外还可以建立其他的中断策略：例如暂停服务或者重新开始服务，但对于哪些包含非标准中断策略的线程或线程池，只能用于能知道这些策略的任务中。 4
任务、进程和线程有何不同
kehui123的专栏
10-17 949
任务、进程和线程有何不同三个词中,任务（task）是最抽象的,是一个一般性的术语,指由软件完成的一个活动。一个任务既可以是一个进程,也可以是一个线程。简而言之,它指的是一系列共同达到某一目的的操作。例如,读取数据并将数据放入内存中。这个任务可以作为一个进程来实现,也可以作为一个线程（或作为一个中断任务）来实现。　　进程（process）常常被定义为程序的执行。可以把一个进程看成是一个独
Java多线程(8)——多线程死锁问题
qq_20761351的博客
08-02 1377
1 基本概括 2 主要介绍 2.1 死锁的概念 所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局。当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。 2.2 死锁产生的原因 1) 系统资源的竞争 通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在 运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争 才可能产生死锁，对可剥夺资源的竞争是不会引起死锁的。 2) 进程推进顺序非法 进程在运行过程中，请求和释放资源
C++编程：多任务与多线程解析
"C++课件_第16章_多任务与多线程编程.ppt" C++的多任务与多线程编程是高级编程的重要组成部分，尤其在现代计算环境中，充分利用多核处理器的能力，提高程序的并发性和效率至关重要。本章主要探讨了C++中的进程、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值