定时器Timer（三）—— 定时器Timer的使用

于 2022-09-09 19:08:13 发布
阅读量461 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44307209/article/details/126740967
版权

目录

5.方法 scheduleAtFixedRate(TimerTask task,Date firstTime,long period) 的测试

  方法 schedule 和方法 scheduleAtFixedRate 都会按顺序执行，所以不要考虑非线程安全的情况。
  方法 schedule 和 scheduleAtFixedRate 主要的区别只在于不延时的情况。
  使用 schedule 方法：如果执行任务的时间没有被延时，那么下一次任务的执行时间参考的是上一次任务的“开始”时的时间来计算。
  使用 scheduleAtFixedRate 方法：如果执行任务的时间没有被延时，那么下一次任务的执行时间参考的是上一次任务的“结束”时的时间来计算。
  延时的情况则没有区别，也就是使用 schedule 或 scheduleAtFixedRate 方法都是如果执行任务的时间被延时，那么下一次任务的执行时间参考的是上一次任务“结束”时的时间来计算。

1.测试 schedule 方法任务不延时

创建项目5.1.5，创建java类Run1.java代码如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Run1 {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask1 extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了!时间为：" + new Date());
                Thread.sleep(1000);
                System.out.println("1 end 运行了!时间为：" + new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        try {
            MyTask1 task1 = new MyTask1();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString1 = "2022-9-7 11:13:00";
            Date dateRef1 = sdf1.parse(dataString1);
            System.out.println("字符串1时间：" + dateRef1.toLocaleString() + "当前时间：" + new Date().toLocaleString());
            timer.schedule(task1, dateRef1, 3000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

字符串1时间：2022-9-3 11:13:00当前时间：2022-9-3 11:12:17
1 begin 运行了!时间为：Sat Sep 03 11:13:00 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:13:01 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:13:03 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:13:04 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:13:06 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:13:07 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:13:09 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:13:10 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:13:12 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:13:13 CST 2022

没有延时的运行效果

  控制台打印的结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则下一次执行任务的时间是上一次任务的开始时间加上 delay 时间。

2.测试 schedule 方法任务延时

创建java类Run2.java代码如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Run2 {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask1 extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了!时间为：" + new Date());
                Thread.sleep(5000);
                System.out.println("1 end 运行了!时间为：" + new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        try {
            MyTask1 task1 = new MyTask1();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString1 = "2022-9-8 11:31:00";
            Date dateRef1 = sdf1.parse(dataString1);
            System.out.println("字符串1时间：" + dateRef1.toLocaleString() + "当前时间：" + new Date().toLocaleString());
            timer.schedule(task1, dateRef1, 2000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

字符串1时间：2022-9-3 11:31:00当前时间：2022-9-3 11:30:51
1 begin 运行了!时间为：Sat 03 11:31:00 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:31:05 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:31:05 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:31:10 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:31:10 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:31:15 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:31:15 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:31:20 CST 2022
1 begin 运行了!时间为：Sat Sep 03 11:31:20 CST 2022
1 end 运行了!时间为：Sat Sep 03 11:31:25 CST 2022

任务延时的效果

  如果执行任务的时间被延时(执行任务的时间大于 delay 的时间)，那么下一次任务的执行时间以上一次任务“结束”时的时间为参考来计算。

3.测试 scheduleAtFixedRate 方法任务不延时

创建java类Run3.java代码如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Run3 {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask1 extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了!时间为：" + new Date());
                Thread.sleep(2000);
                System.out.println("1 end 运行了!时间为：" + new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        try {
            MyTask1 task1 = new MyTask1();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString1 = "2022-9-2 12:31:00";
            Date dateRef1 = sdf1.parse(dataString1);
            System.out.println("字符串1时间：" + dateRef1.toLocaleString() + "当前时间：" + new Date().toLocaleString());
            timer.schedule(task1, dateRef1, 3000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

字符串1时间：2022-9-2 12:31:00当前时间：2022-9-3 13:51:42
1 begin 运行了!时间为：Sat Sep 03 13:51:42 CST 2022
1 end 运行了!时间为：Sat Sep 03 13:51:44 CST 2022
1 begin 运行了!时间为：Sat Sep 03 13:51:45 CST 2022
1 end 运行了!时间为：Sat Sep 03 13:51:47 CST 2022
1 begin 运行了!时间为：Sat Sep 03 13:51:48 CST 2022
1 end 运行了!时间为：Sat Sep 03 13:51:50 CST 2022
1 begin 运行了!时间为：Sat Sep 03 13:51:51 CST 2022
1 end 运行了!时间为：Sat Sep 03 13:51:53 CST 2022
1 begin 运行了!时间为：Sat Sep 03 13:51:54 CST 2022
1 end 运行了!时间为：Sat Sep 03 13:51:56 CST 2022

没有被延时的运行结果

  控制台打印的结果证明，如果执行任务的时间没有被延时，则下一次认知性任务的时间是上一次任务的开始时间加上 delay 时间。

4.测试 scheduleAtFixedRate 方法任务延时

创建java类Run4.java代码如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Run4 {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask1 extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了!时间为：" + new Date());
                Thread.sleep(5000);
                System.out.println("1 end 运行了!时间为：" + new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        try {
            MyTask1 task1 = new MyTask1();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString1 = "2022-9-8 14:38:00";
            Date dateRef1 = sdf1.parse(dataString1);
            System.out.println("字符串1时间：" + dateRef1.toLocaleString() + "当前时间：" + new Date().toLocaleString());
            timer.schedule(task1, dateRef1, 2000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

字符串1时间：2022-9-3 14:38:00当前时间：2022-9-3 14:37:36
1 begin 运行了!时间为：Sat Sep 03 14:38:00 CST 2022
1 end 运行了!时间为：Sat Sep 03 14:38:05 CST 2022
1 begin 运行了!时间为：Sat Sep 03 14:38:05 CST 2022
1 end 运行了!时间为：Sat Sep 03 14:38:10 CST 2022
1 begin 运行了!时间为：Sat Sep 03 14:38:10 CST 2022
1 end 运行了!时间为：Sat Sep 03 14:38:15 CST 2022
1 begin 运行了!时间为：Sat Sep 03 14:38:15 CST 2022
1 end 运行了!时间为：Sat Sep 03 14:38:20 CST 2022
1 begin 运行了!时间为：Sat Sep 03 14:38:20 CST 2022
1 end 运行了!时间为：Sat Sep 03 14:38:25 CST 2022

任务延时的运行结果

  从控制台打印的结果来看，如果执行任务的时间没有被延时，那么下一次任务的执行时间以上一次任务“结束”时的时间为参考来计算。

5.验证 schedule 方法不具有追赶执行性

创建java类Run5.java代码如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Run5 {
    private static Timer timer = new Timer();
    static public class MyTask1 extends TimerTask {
        @Override
        public void run() {
            System.out.println("1 begin 运行了!时间为：" + new Date());
            System.out.println("1 end 运行了!时间为：" + new Date());
        }
    }
    public static void main(String[] args) {
        try {
            MyTask1 task1 = new MyTask1();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString1 = "2022-9-3 16:18:00";
            Date dateRef1 = sdf1.parse(dataString1);
            System.out.println("字符串1时间：" + dateRef1.toLocaleString() + "当前时间：" + new Date().toLocaleString());
            timer.schedule(task1, dateRef1, 5000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

字符串1时间：2022-9-3 16:18:00当前时间：2022-9-3 19:08:36
1 begin 运行了!时间为：Sat Sep 08 19:08:36 CST 2022
1 end 运行了!时间为：Sat Sep 08 19:08:36 CST 2022
1 begin 运行了!时间为：Sat Sep 08 19:08:41 CST 2022
1 end 运行了!时间为：Sat Sep 08 19:08:41 CST 2022
1 begin 运行了!时间为：Sat Sep 08 19:08:46 CST 2022
1 end 运行了!时间为：Sat Sep 08 19:08:46 CST 2022
1 begin 运行了!时间为：Sat Sep 08 19:08:51 CST 2022
1 end 运行了!时间为：Sat Sep 08 19:08:51 CST 2022
1 begin 运行了!时间为：Sat Sep 08 19:08:56 CST 2022
1 end 运行了!时间为：Sat Sep 08 19:08:56 CST 2022

不追赶的情况

  任务计划时间早于当前时间，而任务计划时间到当前时间之间的时间所对应的 Task 任务被取消了，不执行了。这就是 Task 任务不追赶的情况。

6.验证 scheduleAtFixedRate 方法具有追赶执行性

创建java类Run6.java代码如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Run6 {
    private static Timer timer = new Timer();

    static public class MyTask1 extends TimerTask {
        @Override
        public void run() {
            System.out.println("1 begin 运行了!时间为：" + new Date());
            System.out.println("1 end 运行了!时间为：" + new Date());
        }
    }

    public static void main(String[] args) {
        try {
            MyTask1 task1 = new MyTask1();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString1 = "2022-9-3 19:40:50";
            Date dateRef1 = sdf1.parse(dataString1);
            System.out.println("字符串1时间：" + dateRef1.toLocaleString() + "当前时间：" + new Date().toLocaleString());
            timer.scheduleAtFixedRate(task1, dateRef1, 5000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

字符串1时间：2022-9-8 19:40:50当前时间：2022-9-8 19:42:47
1 begin 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 end 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 begin 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 end 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 begin 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 end 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 begin 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 end 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 begin 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 end 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 begin 运行了!时间为：Thu Sep 08 19:42:47 CST 2022
1 end 运行了!时间为：Thu Sep 08 19:42:47 CST 2022

追赶的情况

  任务计划时间早于当前时间，而任务计划时间到当前时间之间的时间所对应的 Task 任务被“补充性”执行了，这就是 Task 任务追赶执行的特性


以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git

Yarrow-Y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
定时器Timer（一）—— 定时器Timer的使用
qq_44307209的博客
09-09 4335
定时 / 计划功能在移动开发领域使用较多，比如 Android 技术。定时计划任务功能在 Java 中主要使用的就是 Timer 对象，他在内部使用多线程的方式进行处理，所以它和线程技术还是有非常大的关联的。在 JDK 库中 Timer 类主要负责计划任务的功能，也就是在指定的时间开始执行某一个任务。Timer 类的主要作用就是设置计划任务，但封装任务的类却是 TimerTask。执行计划任务的代码要放入 TimerTask 的子类中，因为 TimerTask 是一个抽象类。
定时器Timer的使用
飞翔的宇宙
07-11 461
一.序言:  在JDK库汇总的Timer类主要负责计划任务的功能,也就是在指定的时间开始执行某一个任务,Timer类的主要左右就是设置计划任务,但封装任务的类却是TimerTask类,执行计划任务的代码要放入TimerTask的子类中,因为TimerTask是一个抽象类. 二.demo演示: 1.指定未来的时间执行任务: public class MyTask1 extends Time...
【探索】定时器Timer的使用
小三七的学习
06-29 412
定时器Timer的使用 Time类的主要作用就是设置计划任务，但封装任务的类却是TimeTask类，执行计划任务的代码要放入TimerTask的子类中，因为TimeTask是一个抽象类。 1.方法schedule（TimeTask task，Date Time）的测试 该方法的作用是在指定的日期执行一次某一任务。 1.1 执行任务的时间晚于当前时间：在未来执行的效果 创建Run1.java类： import java.text.ParseException; import java.text.Simple
Timer的schedule和scheduleAtFixedRate方法的区别解析
热门推荐
星星的技术专栏
11-27 6万+
在java中，Timer类主要用于定时性、周期性任务 的触发，这个类中有两个方法比较难理解，那就是schedule和scheduleAtFixedRate方法，在这里就用实例分析一下 （1）schedule方法：“fixed-delay”；如果第一次执行时间被delay了，随后的执行时间按照实际执行完成的时间点进行计算 （2）scheduleAtFixedRate方法：“fixed-rate”；如果第一次执行时间被delay了，随后的执行时间按照初始设定时间点进行计算，并且为了”catch up”会多
Javad多线程之定时器Timer
大鹏视界U
04-26 230
定时器Timer的使用 在JDK库中，Timer类主要负责计划任务的功能，也就是在指定的时间开始执行某一个任务 Timer类的主要作用就是设置计划任务，但封装任务的类却是TimerTask类 执行计划任务的代码要放入TimerTask的子类中，因为TimerTask是一个抽象类。 5.1.1 方法schedule(TimerTask task,Date time) 该方法的作用是在指定的日期执行一...
C++定时器Timer在项目中的使用方法
08-26
C++定时器Timer在项目中的使用方法 C++定时器Timer在项目中的使用方法是指在项目中使用C++语言实现定时器的使用方法。定时器是计算机编程中的一种机制，用于在特定的时间间隔内执行特定的任务。本文将详细介绍C++...
Java定时器Timer使用方法详解
08-28
Java定时器Timer使用方法详解 Java中的定时器Timer是使用Timer类和TimerTask类来实现的，Timer类负责计划任务的功能，而TimerTask类则是封装要执行的任务的类。下面将详细介绍Java定时器Timer的使用方法。 一、...
java定时器timer的使用方法代码示例
08-28
总结来说，Java定时器（Timer）是Java中一个简单实用的工具，适合在需要定时执行任务的场景下使用。通过结合Servlet的监听器，我们可以实现Web应用启动时自动初始化定时任务，以满足各种自动化需求。在实际开发中，...
Java定时器Timer简述
08-31
通过以上介绍，我们了解到Java定时器Timer的基本使用方式及其背后的机制。在实际开发中，Timer可以用于实现定时执行的任务，例如定时备份、日志清理等场景。然而，对于需要高精度定时或者实时性的应用，可能需要考虑...
GD32 Timer定时器的使用
07-03
在实际应用中，例如在"04-Timer"文件中，你可能找到示例代码展示了如何配置和使用定时器中断。通过分析和理解这些代码，你将更深入地掌握GD32F330定时器中断的用法。 总结来说，GD32F330 Timer的中断功能允许开发者...
定时器（Timer）
m0_60265426的博客
03-26 1万+
1.时钟 时钟就是一个可以产生周期性信号的设备。 时钟信号就是周期性变化的信号。 T:时钟周期 最小重复的信号单元的时间长度，基本单元为s(秒) F:时钟频率 1s内有多少个重复的信号单元，单位为Hz --->T * F = 1 2.为什么需要时钟？ 时钟的最主要的目的是为了同步信号。 设备之间的同步是通过时钟信号来进行的。 3.时钟信号是怎么产生的？ 在自然界中有一些物体天生就会产生摆动(振动)–>石英晶体 如果想利用石英晶体规则地、周期性的产生方波信号，需要一些电路来保证，如 晶振电路：
各种android定时器验证
patch的专栏
07-20 1716
android系统升级到4.4以上，由于存在一个定时器对齐执行（好像是这么个名字），造成定时器每5分钟才能执行一次，很多场景下需要定时执行的任务都必须5分钟才执行一次，典型的场景比如socket长连接的心跳，为了维持socket长连接，必须每隔固定时间由app向server端发送一个心跳包，以便让server知道该socket还是正常的，无论设置是40秒还是多少秒，心跳定时器都会被合并成5分钟执行
STM32 学习笔记：TIME定时器详解
Cheatscat的博客
09-07 6735
STM32 单片机的定时器的确很强大，参考说明书中就占了一百多页，占参考手册1/4 有多了。 STM32的定时器分了好几个类别，各个类别针对功能作用都不大相同。 分有： 一、高级定时器        二、通用定时器        三、基本定时器        四、看门狗定时器        五、SysTick定时器       其中看门狗定时器和SysTick定时器本篇笔记阐述，
定时器Timer和周期性定时器Ticker
磨镜台的博客
04-11 1015
单次定时器Timer 创建timer : = time.NewTimer(d duration) 该函数返回一个*Timer类型 Timer类型如下： type Timer struct { C <-chan Time r runtimeTimer } 延迟定时的三种方法 sleep(duration) timer := newTimer(duration) 然后<- ti...
任务调度框架（6）番外：使用 SpringBoot2.X 实现 Quartz 动态任务的分布式调度
Sam Blog
05-09 3561
文章目录SpringBoot2 集成 Quartz集成简单实现Pom依赖编码功能实现自动配置实现分析自动化配置分析 `QuartzAutoConfiguration`支持功能配置 `QuartzProperties`小结Quartz 实现分布式调度回顾分析配置简单实现Quartz 的任务动态实现数据使用数据库保存任务计划的动态管理手动配置实现的原理动态管理：创建计划任务引擎类任务状态与计划依赖小结...
STM32系统学习——TIM（基本定时器）
zxh1592000的博客
12-11 5万+
一、定时器分类 STM32F1 系列中，除了互联型的产品，共有 8 个定时器，分为基本定时器，通用定时器和高级定时器。基本定时器 TIM6 和 TIM7 是一个 16 位的只能向上计数的定时器，只能定时，没有外部 IO。通用定时器 TIM2/3/4/5 是一个 16 位的可以向上/下计数的定时器，可以定时，可以输出比较，可以输入捕捉，每个定时器有四个外部 IO。高级定时器 TIM1/8是一个 16
定时器第1篇——Timer详解及根据测试结果分析schedule与scheduleAtFixedRate区别
ShenDaiSun的博客
01-20 1707
1.概述                 Timer进行一个完整的定时任务需要结合TimerTask类一起使用。         Timer：是JDK提供的一个定时器工具，使用时会在主线程之外开启一个单独的线程用于执行指定的计划任务。可安排任务执行一次（延迟执行）或者定期重复执行多次。         TimerTask：是一个实现了Runnable接口的抽象类，代表一个可以被Timer执行...
定时器new Timer().schedule()的使用
光着脚丫子飙五环
09-27 2万+
http://linhongyu.blog.51cto.com/6373370/1437561 Timer是一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。实际上是个线程，定时调度所拥有的TimerTasks。 TimerTask是一个抽象类，它的子类由 Timer 安排为一次执行或重复执行的任务。实际上就是一个拥有run方法的类，需要定时执行的代码放到r
Timer中schedule和scheduleAtFixedRate方法区别
lolichan的博客
04-23 570
转自：https://blog.csdn.net/ling912439122/article/details/52712406   Timer，一般用来做延时任务或者循环定时执行的任务。 例如：指定在一小时后闹钟就响了，或者每天6:00响，这些都是延时任务或者是定时循环的任务   使用Timer的时候，必须要有一个TimerTask去执行任务，这是一个线程，它实现了Runnable接...
Linux 定时器timer_list
最新发布
07-12
在使用 timer_list 时，可以使用以下函数进行初始化和操作： - `timer_setup(struct timer_list *timer, void (*function)(unsigned long), unsigned int flags)`：初始化一个定时器，并指定回调函数和标志。 - `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值