相关疑难解决方法(0)

在 Node.js 中，我可以设置触发某个事件的时间间隔，

function intervalFunc() {
  console.log('whelp, triggered again!');
}

setInterval(intervalFunc, 1500);

然而，Tokio间隔的界面有点复杂。这似乎与间隔的更字面定义有关，而不是按间隔调用函数，它只是停止线程直到时间过去（使用.await）。

Tokio 中是否有一个原语“每 x 秒”调用一个函数或类似函数？如果没有，是否有一个习语可以做到这一点？

我只需要定期运行一个函数...我也不关心其他线程。它只是 Tokio 事件循环中的一个函数。

我正在Rust中创建一个小的ncurses应用程序,需要与子进程通信.我已经有了一个用Common Lisp编写的原型; 这里的gif 将有希望展示我想做的事情.我正在尝试重写它,因为CL为这么小的工具使用了大量的内存.

我之前没有使用过Rust(或其他低级语言),而且我在弄清楚如何与子进程交互时遇到了一些麻烦.

我目前正在做的大致是这样的:

1. 创建流程:

   let mut program = match Command::new(command)
       .args(arguments)
       .stdin(Stdio::piped())
       .stdout(Stdio::piped())
       .stderr(Stdio::piped())
       .spawn()
   {
       Ok(child) => child,
       Err(_) => {
           println!("Cannot run program '{}'.", command);
           return;
       }
   };
   

   Run Code Online (Sandbox Code Playgroud)

2. 将它传递给无限(直到用户退出)循环,该循环读取并处理输入并像这样监听输出(并将其写入屏幕):

   fn listen_for_output(program: &mut Child, output_viewer: &TextViewer) {
       match program.stdout {
           Some(ref mut out) => {
               let mut buf_string = String::new();
               match out.read_to_string(&mut buf_string) {
                   Ok(_) => output_viewer.append_string(buf_string),
                   Err(_) => return,
               };
           }
           None => return,
       };
   }
   

   Run Code Online (Sandbox Code Playgroud)

read_to_string然而,调用阻止程序直到进程退出.从我所看到的read_to_end,read似乎也阻止.如果我尝试运行类似于ls哪个退出的东西,它可以工作,但是有些东西不能退出, …

我阅读了tokio文档,我想知道将来封装昂贵的同步I/O的最佳方法是什么.

使用reactor框架,我们可以获得绿色线程模型的优势:一些OS线程通过执行程序处理大量并发任务.

未来的tokio模型是需求驱动的,这意味着未来本身将轮询其内部状态以提供有关其完成的信息; 允许背压和取消功能.据我了解,未来的投票阶段必须是非阻塞才能运作良好.

I/OI想要封装可以看作是一个长期的原子和昂贵的操作.理想情况下,独立任务将执行I/O,并且相关联的未来将轮询I/O线程以获得完成状态.

我看到的两个唯一选择是:

• 将阻塞I/O包含poll在将来的功能中.
• 产生OS线程以执行I/O并使用未来机制轮询其状态,如文档中所示

据我所知,这两种解决方案都不是最优的,并且没有充分利用绿色线程模型(首先不在文档中建议,其次不通过reactor框架提供的执行程序).还有其他解决方案吗？

我试图理解Future::select:在这个例子中,首先返回具有较长时间延迟的未来.

当我通过它的例子阅读这篇文章时,我得到了认知失调.作者写道:

该select函数运行两个(或者更多select_all)期货,并返回第一个完成.这对于实现超时很有用.

看来我不明白这种感觉select.

extern crate futures;
extern crate tokio_core;

use std::thread;
use std::time::Duration;
use futures::{Async, Future};
use tokio_core::reactor::Core;

struct Timeout {
    time: u32,
}

impl Timeout {
    fn new(period: u32) -> Timeout {
        Timeout { time: period }
    }
}

impl Future for Timeout {
    type Item = u32;
    type Error = String;

    fn poll(&mut self) -> Result<Async<u32>, Self::Error> {
        thread::sleep(Duration::from_secs(self.time as u64));
        println!("Timeout is done with time {}.", …