rust学习-tokio::time

已于 2023-08-11 20:11:22 修改
阅读量1.1k 收藏
点赞数
分类专栏： rust 文章标签： rust 学习
于 2023-08-11 20:11:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangkai6666/article/details/132239344
版权

示例

use std::time::Duration;
use tokio::{task, time::interval};

#[tokio::main]
async fn main() {
    let mut interval = interval(Duration::from_secs(1));
    let handle = task::spawn(async move {
        loop {
            interval.tick().await;
            println!("tick");
        }
    });

    handle.await.unwrap();
}

interval和sleep的区别

tick周期大于异步任务周期

use tokio::time;
use chrono::{DateTime, Local};

async fn task_that_takes_a_second() {
    let now: DateTime<Local> = Local::now();
    println!("Current task time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    time::sleep(time::Duration::from_secs(2)).await;
    let now: DateTime<Local> = Local::now();
    println!("Current task time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
}

#[tokio::main]
async fn main() {
    let mut interval = time::interval(time::Duration::from_secs(3));
    for _i in 0..5 {
        let now: DateTime<Local> = Local::now();
        println!("Current main time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
        interval.tick().await;
        let now: DateTime<Local> = Local::now();
        println!("Current main time mid is: {}", now.format("%Y-%m-%d %H:%M:%S"));
        task_that_takes_a_second().await;
        let now: DateTime<Local> = Local::now();
        println!("Current main time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    }
}

Current main time before is: 2023-08-11 13:46:48
Current main time mid is: 2023-08-11 13:46:48 // 第一次，立即触发
Current task time before is: 2023-08-11 13:46:48
Current task time after is: 2023-08-11 13:46:50
Current main time after is: 2023-08-11 13:46:50

Current main time before is: 2023-08-11 13:46:50
Current main time mid is: 2023-08-11 13:46:51 // 距离上一次3秒
Current task time before is: 2023-08-11 13:46:51
Current task time after is: 2023-08-11 13:46:53
Current main time after is: 2023-08-11 13:46:53

Current main time before is: 2023-08-11 13:46:53
Current main time mid is: 2023-08-11 13:46:54 // 距离上一次3秒
Current task time before is: 2023-08-11 13:46:54
Current task time after is: 2023-08-11 13:46:56
Current main time after is: 2023-08-11 13:46:56

Current main time before is: 2023-08-11 13:46:56
Current main time mid is: 2023-08-11 13:46:57  // 距离上一次3秒
Current task time before is: 2023-08-11 13:46:57
Current task time after is: 2023-08-11 13:46:59
Current main time after is: 2023-08-11 13:46:59

Current main time before is: 2023-08-11 13:46:59
Current main time mid is: 2023-08-11 13:47:00 // 距离上一次3秒
Current task time before is: 2023-08-11 13:47:00
Current task time after is: 2023-08-11 13:47:02
Current main time after is: 2023-08-11 13:47:02

tick周期小于异步任务周期

use tokio::time;
use chrono::{DateTime, Local};

async fn task_that_takes_a_second() {
    let now: DateTime<Local> = Local::now();
    println!("Current task time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    time::sleep(time::Duration::from_secs(5)).await;
    let now: DateTime<Local> = Local::now();
    println!("Current task time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
}

#[tokio::main]
async fn main() {
    let mut interval = time::interval(time::Duration::from_secs(3));
    for _i in 0..5 {
        let now: DateTime<Local> = Local::now();
        println!("Current main time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
        interval.tick().await;
        let now: DateTime<Local> = Local::now();
        println!("Current main time mid is: {}", now.format("%Y-%m-%d %H:%M:%S"));
        task_that_takes_a_second().await;
        let now: DateTime<Local> = Local::now();
        println!("Current main time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    }
}

Current main time before is: 2023-08-11 13:51:24
Current main time mid is: 2023-08-11 13:51:24
Current task time before is: 2023-08-11 13:51:24
Current task time after is: 2023-08-11 13:51:29
Current main time after is: 2023-08-11 13:51:29

Current main time before is: 2023-08-11 13:51:29
Current main time mid is: 2023-08-11 13:51:29 // 举例上一次超过3秒
Current task time before is: 2023-08-11 13:51:29
Current task time after is: 2023-08-11 13:51:34
Current main time after is: 2023-08-11 13:51:34

Current main time before is: 2023-08-11 13:51:34
Current main time mid is: 2023-08-11 13:51:34  // 举例上一次超过3秒
Current task time before is: 2023-08-11 13:51:34
Current task time after is: 2023-08-11 13:51:39
Current main time after is: 2023-08-11 13:51:39

Current main time before is: 2023-08-11 13:51:39
Current main time mid is: 2023-08-11 13:51:39  // 举例上一次超过3秒
Current task time before is: 2023-08-11 13:51:39
Current task time after is: 2023-08-11 13:51:44
Current main time after is: 2023-08-11 13:51:44

Current main time before is: 2023-08-11 13:51:44
Current main time mid is: 2023-08-11 13:51:44  // 举例上一次超过3秒
Current task time before is: 2023-08-11 13:51:44
Current task time after is: 2023-08-11 13:51:49
Current main time after is: 2023-08-11 13:51:49

timeout

use tokio::time::{timeout, Duration};
use tokio::time;
use chrono::{DateTime, Local};

async fn long_future() {
    let now: DateTime<Local> = Local::now();
    println!("Current task time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    time::sleep(time::Duration::from_secs(5)).await;
    let now: DateTime<Local> = Local::now();
    println!("Current task time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
}

#[tokio::main]
async fn main() {
    for _i in 0..5 {
        let now: DateTime<Local> = Local::now();
        println!("Current main time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    
        let res = timeout(Duration::from_secs(1), long_future()).await;
    
        let now: DateTime<Local> = Local::now();
        println!("Current main time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
        
        if res.is_err() {
                println!("operation timed out");
        }
    }
}

interval_at

pub fn interval_at(start: Instant, period: Duration) -> Interval

use tokio::time::{interval_at, Duration, Instant};
use chrono::{DateTime, Local};

#[tokio::main]
async fn main() {
    let start = Instant::now() + Duration::from_secs(5);
    let mut interval = interval_at(start, Duration::from_secs(3)); // 不会立即开始

    let now: DateTime<Local> = Local::now();
    println!("Current task time now is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    interval.tick().await; // ticks after 3s
    let now: DateTime<Local> = Local::now();
    println!("Current task time now is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    interval.tick().await; // ticks after 3s
    let now: DateTime<Local> = Local::now();
    println!("Current task time now is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    interval.tick().await; // ticks after 3s
    let now: DateTime<Local> = Local::now();
    println!("Current task time now is: {}", now.format("%Y-%m-%d %H:%M:%S"));
}

Current task time now is: 2023-08-11 19:34:30
Current task time now is: 2023-08-11 19:34:35
Current task time now is: 2023-08-11 19:34:38
Current task time now is: 2023-08-11 19:34:41

MissedTickBehavior

use tokio::time;
use chrono::{DateTime, Local};
use tokio::time::MissedTickBehavior;

async fn task_that_takes_a_second() {
    let now: DateTime<Local> = Local::now();
    println!("Current task time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    time::sleep(time::Duration::from_secs(5)).await;
    let now: DateTime<Local> = Local::now();
    println!("Current task time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
}

#[tokio::main]
async fn main() {
    let mut interval = time::interval(time::Duration::from_secs(3));
    interval.set_missed_tick_behavior(MissedTickBehavior::Delay);

        for _i in 0..5 {
            let now: DateTime<Local> = Local::now();
            println!("Current main time before is: {}", now.format("%Y-%m-%d %H:%M:%S"));
            interval.tick().await;
            let now: DateTime<Local> = Local::now();
            println!("Current main time mid is: {}", now.format("%Y-%m-%d %H:%M:%S"));
            task_that_takes_a_second().await;
            let now: DateTime<Local> = Local::now();
            println!("Current main time after is: {}", now.format("%Y-%m-%d %H:%M:%S"));
    }
}

在 Rust 的 tokio 库中，MissedTickBehavior 是一个枚举类型，表示当 Interval 频率计时器在某个周期中错过某个间隔时如何处理。具体来说，它有以下三个变体：

  • Burst：表示如果错过计时间隔，则会立即执行多个周期，直到被重新赶上。
  • Delay：表示如果错过计时间隔，则在下一个可用的计时间隔时执行周期。
  • Skip：表示如果错过计时间隔，则跳过它并继续执行下一个计时间隔的周期。
    一般情况下， Burst 和 Delay 会导致执行速率加速，Skip 会导致执行速率降低但保证数据与频率同步。
#[tokio::main]
async fn main() {
    let mut interval_burst = time::interval(Duration::from_millis(5));
    interval_burst.set_missed_tick_behavior(time::MissedTickBehavior::Burst);

    let mut interval_delay = time::interval(Duration::from_millis(5));
    interval_delay.set_missed_tick_behavior(time::MissedTickBehavior::Delay);

    let mut count_burst = 0;
    let mut count_delay = 0;

    // 运行到20000次以上才会看出差异
    loop {
        select! {
            _ = interval_burst.tick() => {
                count_burst += 1;
                println!("Burst: tick #{}", count_burst);
            }
            _ = interval_delay.tick() => {
                count_delay += 1;
                println!("Delay: tick #{}", count_delay);
            }
        }
    }
}
~kiss~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Let‘s Go Rust 系列之定时器 Ticker Timer
Deepexi_Date的博客
10-26 2288
前言 在实际项目开发中，经常会有定时任务的功能开发需求，定时任务主要分为两种， 1，在固定的时刻执行某个任务，也就是 Timer 2，基于固定的时间间隔，周期的执行某个任务，也就是Ticker ​ 很多基于时间的调度任务框架都离不开这两种类型。 本文将会分别介绍在Golang和Rust语言中这两种定时器类型以及它们的使用方法。 Golang Golang的标准库 time 中就包含了 Ticker 和 Timer 这两种定时器类型，在package中添加引用就可,如下： ​ import ( "ti
一个用 Rust 编写的简单 CLI 番茄钟定时器。
06-28
番茄钟一个用 Rust 编写的简单 CLI 番茄钟定时器。基于番茄工作法。适用于任何支持桌面通知的平台。例子pomodoro 25 4以 25 分钟的工作间隔和 4 分钟的休息间隔开始一个番茄钟会话。
rust 定时执行
已迁移至 https://seekstar.github.io/
08-16 2972
tokio = { "version" = "1.10", features = ["full"] } use tokio::time; async fn print() { let mut interval = time::interval(time::Duration::from_secs(1)); loop { interval.tick().await; println!("2333"); } } #[tokio::main] async
Rust异步并发编程tokio异步运行时讲解和使用，新手必学
最新发布
04-27 1328
Rust 在v1.39版本以后就引入了async关键字，用于支持异步编程。Rust中，async函数或块会被视作一个 Future 对象，async 关键字只是用来定义这个 Future 对象，定义好的这片异步代码并不会自动执行，而是需要和 async 配对的 .await 去驱动它才会执行。用 async 定义异步代码，用 .await 驱动执行。但是 .await 又只能在 async 块中调用。Rust 明确规定了，main 函数前不能加 async 修饰。也就是说，只能写成这种形式。
rust写一个定时备份mysql的脚本
weixin_42589700的博客
12-22 377
在 Rust 中写一个定时备份 MySQL 的脚本，你可以使用 cron 或者其他定时任务工具来执行脚本。 具体步骤如下： 安装 MySQL 驱动，可以使用 Rust 的 mysql 库。 连接到 MySQL 数据库，使用 mysql 库的连接方法。 使用 MySQL 的备份命令(例如 mysqldump)来备份数据库。 设置定时任务，每天或者每周定时执行备份脚本。 这里是一个简单的例...
interval_trees:Rust中间隔树数据结构的一种变体
05-05
介绍 这是间隔树数据结构的一种变体，包含此结构的两种类型-段-点树和点-段树。 段点树允许插入段并查询点，而点段树允许插入点并查询段。 所有操作都以O（log（tree size））复杂度运行。 这些树可以通过您要支持的操作进行参数设置，您可以使用它们来解决以下问题： 在某些点上段的总和是多少？ 在某些方面，细分的结果是什么？ 某段的总和是多少？ 在某些细分市场中最大的优势是什么？ 某段中的最小点是多少？ 注意，这允许解决问题的“在线”版本-即。 细分集和查询的修改可以混合使用。 用法 请参考examples /目录。 命名 我不确定此数据结构的正确名称是什么-我在算法类中以波兰语名称“ drzewoprzedziałowe”学到了该名称，该名称可以转换为“间隔树”之类的名称。 但是，似乎它与标准间隔树实现略有不同-我没有存储所有间隔，而是仅在节点中保留了相关数据。 （尽管，从
uinput-tokio:面向uinput的tokio impl
03-27
use std :: time :: Duration; use tokio; #[tokio::main] async fn main () { let mut device = uinput_tokio :: default () . unwrap () . name ( "test" ) . unwrap () . event (uinput_tokio :: event :: ...
async-injector:用于Rust的React式依赖注入
05-26
这可以作为fake_database示例使用，您可以使用以下命令自己运行它： cargo run --example fake_database use tokio :: time;use tokio_stream :: StreamExt as _;#[derive(Clone)]struct Datab
influxdb-rust:用于InfluxDB时间序列数据库的Rust客户端
05-03
非官方的Rust Rust InfluxDB驱动程序 该库正在进行中。 这意味着您可能需要的功能尚未实现，或者可能会得到更好的处理。 始终欢迎请求请求。 请参阅和。 有关过去更改的列表，请参见 。当前支持的功能读写InfluxDB ...
lg-webos-client:LG WebOS客户端
03-19
用Rust纯洁地编写的简单LG webOS客户端。灵感来自 支持的命令 制作吐司 打开浏览器 关掉 设定频道 设定输入 设置静音 设定音量 获取频道列表 获取当前频道 公开频道 获取外部输入列表 开关量输入 被静音 变音量 播放...
tmq:Tokio的Rust ZeroMQ绑定
05-24
TMQ-Tokio的Rust ZeroMQ绑定 此板条箱桥接了Tokio和ZeroMQ，以允许异步世界中使用ZeroMQ。 变更日志 0.3.0-Tokio 1.0支持 感谢 0.3.0添加了对tokio 1.0的支持！ 当前实现的套接字 请求/回复 发布/订阅 经销商/路由器...
tokio：使用Rust编写可靠的异步应用程序的运行时。 提供IO，网络，调度，计时器等。
02-05
tokio：使用Rust编写可靠的异步应用程序的运行时。 提供IO，网络，调度，计时器等。
timer.rs:Rust计时器的简单实现
05-25
计时器 在Rust中以及针对Rust的Timer的简单实现。 例子 extern crate timer; extern crate chrono; use std :: sync :: mpsc :: channel; let timer = timer :: Timer :: new (); let (tx, rx) = channel (); let _guard = timer. schedule_with_delay (chrono :: Duration :: seconds ( 3 ), move || { tx. send (()). unwrap (); }); rx. recv (). unwrap (); println! ( "This code has been executed after 3 seconds" );
cron:Rust中的cron表达式解析器
05-04
克朗 cron表达式解析器。 与稳定的Rust v1.28.0一起使用。 extern crate cron; extern crate chrono; use cron :: Schedule; use chrono :: Utc; use std :: str :: FromStr; fn main () { // sec min hour day of month month day of week year let expression = "0 30 9,12,15 1,15 May-Aug Mon,Wed,Fri 2018/2" ; let schedule = Schedule :: from_str (expression). unwrap (); println! ( "
定时器与多线程任务调度器使用
06-10
定时器与多线程任务调度器使用定时器与多线程任务调度器使用
系统的延时及定时任务
cute
08-04 218
一、延时任务 at  21:11              设定任务执行时间 at&gt; mkdir  noah       任务动作 at&gt; &lt;EOT&gt;                    用ctrl+D发起任务 at now+1min                  延时1秒        at -l                       查看任务列表  ...
[RUST]tokio异步使用的例子: 简单的标准输入输出服务
小蜗牛之家
12-16 2000
功能：从标准输入stdin获取输入，并原样输出到标准输出stdout； 关联：tokio crate的async、await、spawn、spawn_blocking等功能使用; 依赖：Cargo.toml [dependencies] tokio = { version = "*", features = ["full"] } 代码： main.rs use std::io; use ...
使用Rust开发操作系统(使用中断，时钟中断，键盘驱动)
VenmoSnake的博客
01-17 1357
使用中断，时钟中断，键盘驱动定义一个中断处理函数定义中断向量时钟中断关于时钟中断键盘中断下一步要做什么 在上一篇文章中我们讲述了如何定义一个异常处理函数以及如何向IDT注册异常处理函数，在本篇中我们开始定义一个中断处理函数以及启用我们的中断处理函数 定义一个中断处理函数 定义一个中断函数很简单，函数的签名与异常处理函数的签名一致，只不过中断处理函数是不需要错误返回码的 定义一个基本中断处理函数如下...
rust中常用方法记录（逐渐更新）
YLX
02-19 331
不用&mut也可以修改变量的值，一般用在闭包里。
pyoxidizer init-rust-project D:\pythonxu\dabao会造成什么后果
06-11
执行 `pyoxidizer init-rust-project D:\pythonxu\dabao` 命令会在 `D:\pythonxu\dabao` 目录下创建一个 Rust 项目，并生成一些默认的配置文件和源代码。这些文件包括： - `Cargo.toml`：Rust 项目的配置文件，它包含了项目的名称、版本、依赖项等信息。 - `src/main.rs`：Rust 项目的入口文件，它包含了 Rust 代码的模板。 - `.cargo/config.toml`：Cargo 的配置文件，它包含了 Rust 编译器的选项、依赖项缓存等信息。 如果您已经有一个 Rust 项目，您可以将 `pyoxidizer.bzl` 文件中的 `interpreter` 字段设置为您的 Rust 项目路径，以便 PyOxidizer 使用您的项目作为 Python 解释器。 请注意，执行 `pyoxidizer init-rust-project` 命令不会创建可执行文件，它只是创建一个 Rust 项目并生成一些默认的配置文件和源代码。要打包 Python 应用程序，请使用 `pyoxidizer init` 命令或手动编辑 `pyoxidizer.bzl` 文件。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值