在 Rust 中通过 read_line 输入数据

Question

Alex

Asked:2025-01-20 19:16:05 +0800 CST2025-01-20 19:16:05 +0800 CST 2025-01-20 19:16:05 +0800 CST

如何将代码块放入 impl 中以创建单独的线程？

772

第一个块中给出的代码有效。
如何将其放入impl创建单独线程的单独部分中？
就像第二个代码块一样，其中注意到так не работает.
播放_1

use std::time::{SystemTime, Instant};
use std::thread;
use thread::JoinHandle;


fn main() {

   let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> = thread::spawn(|| {
      let t21: SystemTime = SystemTime::now();
      let start_02 = Instant::now();
      let mut j: usize = 0;
      loop {
         if j == 10 { break; }
         j = j + 1;
      }
      let t22: SystemTime = SystemTime::now();
      let d2:(usize, SystemTime, SystemTime, core::time::Duration) = (j, t21, t22, start_02.elapsed());
      d2
   });

   
   let t11: SystemTime = SystemTime::now();
   let start_01 = Instant::now();
   let mut i: usize = 0;
   loop {
      if i == 10 { break; }
      i = i + 1;
   }
   let t12 = SystemTime::now();

   
   let d2 = handle.join().expect("thread panicked :...");

   println!("i = {:?} \nt11 = {:?} \nt12 = {:?}", i, t11, t12);
   println!("dt_01 = {:?}\n", start_01.elapsed());
   //
   println!("j = {:?} \nt21 = {:?} \nt22 = {:?}", &d2.0, &d2.1, &d2.2);
   println!("dt_02 = {:?}\n", &d2.3);
}

像这样的东西：
play_2

use std::time::{SystemTime, Instant};
use std::thread;
use thread::JoinHandle;

struct Thd {
   a: usize, 
   b: SystemTime, 
   c: SystemTime,
   d: core::time::Duration,
}

impl Thd {

   pub fn new() -> JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> {

     thread::spawn(|| {
       let t21: SystemTime = SystemTime::now();
       let start_02 = Instant::now();
       let mut j: usize = 0;
       loop {
         if j == 1_000_000 { break; }
         j = j + 1;
       }
       let t22: SystemTime = SystemTime::now();
       
       let d: Thd = Thd01 {a: j, b: t21, c: t22, d:start_02.elapsed()};
       
       let d2:(usize, SystemTime, SystemTime, core::time::Duration) = (d.a, d.b, d.c, d.d);

       d2
     });
   }
}

fn main() {
   // Error `так не работает`:
   let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> = Thd::new();

   
   let t11: SystemTime = SystemTime::now();
   let start_01 = Instant::now();
   let mut i: usize = 0;
   loop {
      if i == 1_000_000 { break; }
      i = i + 1;
   }
   let t12 = SystemTime::now();

   
   let d2 = handle.join().expect("thread panicked :...");

   println!("i = {:?} \nt11 = {:?} \nt12 = {:?}", i, t11, t12);
   println!("dt_01 = {:?}\n", start_01.elapsed());
   //
   println!("j = {:?} \nt21 = {:?} \nt22 = {:?}", &d2.0, &d2.1, &d2.2);
   println!("dt_02 = {:?}\n", &d2.3);
}

更新_01

播放_3

use std::time::{SystemTime, Instant};
use std::thread;
use thread::JoinHandle;

struct Thd {
   a: usize, 
   b: SystemTime, 
   c: SystemTime,
   dt: core::time::Duration,
}

impl Thd {

   pub fn new() -> JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> {
   
     let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> =
     thread::spawn(|| {
       let t21: SystemTime = SystemTime::now();
       let start_02 = Instant::now();
       let mut j: usize = 0;
       loop {
         if j == 1_000_000 { break; }
         j = j + 1;
       }
     
       let t22: SystemTime = SystemTime::now();
       let d: Thd = Thd {a: j, b: t21, c: t22, dt:start_02.elapsed()};
       let d2:(usize, SystemTime, SystemTime, core::time::Duration) = (d.a, d.b, d.c, d.dt);
       d2
     });
     handle
   }
}

fn main() {
   // `так работает`:
   let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> = Thd::new();

   
   let t11: SystemTime = SystemTime::now();
   let start_01 = Instant::now();
   let mut i: usize = 0;
   loop {
      if i == 1_000_000 { break; }
      i = i + 1;
   }
   let t12 = SystemTime::now();

   
   let d2 = handle.join().expect("thread panicked :...");

   println!("i = {:?} \nt11 = {:?} \nt12 = {:?}", i, t11, t12);
   println!("dt_01 = {:?}\n", start_01.elapsed());
   //
   println!("j = {:?} \nt21 = {:?} \nt22 = {:?}", &d2.0, &d2.1, &d2.2);
   println!("dt_02 = {:?}\n", &d2.3);
}

/*

i = 1000000 
t11 = SystemTime { tv_sec: 1737389697, tv_nsec: 383198522 } 
t12 = SystemTime { tv_sec: 1737389697, tv_nsec: 385890160 }
dt_01 = 2.931694ms

j = 1000000 
t21 = SystemTime { tv_sec: 1737389697, tv_nsec: 383252593 } 
t22 = SystemTime { tv_sec: 1737389697, tv_nsec: 386045474 }
dt_02 = 2.792891ms

*/

1 个回答

Voted

extrn · Answer 1 · 2025-01-21T23:10:18+08:00

我想设置 impl 中线程的 main 迭代次数

请输入您的答案

考虑到Thd这不是线程本身，而是其工作的结果，特别是因为它可以在不创建线程的情况下使用，因此从实现中完全排除线程的提及并重命名它是有意义的，并稍微概括一下。

use std::fmt;
use std::thread;
use std::time::{Duration, Instant, SystemTime};

#[derive(Debug)]
pub struct Metrics<T> {
    result: T,
    start: SystemTime,
    stop: SystemTime,
    elapsed: Duration,
}

impl<T> Metrics<T> {
    pub fn gather(f: impl FnOnce() -> T) -> Self {
        let start = SystemTime::now();
        let instant = Instant::now();
        let result = f();
        let stop = SystemTime::now();
        let elapsed = instant.elapsed();
        Self { result, start, stop, elapsed }
    }
}

impl<T: fmt::Display> fmt::Display for Metrics<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        writeln!(f, "result  = {}", self.result)?;
        writeln!(f, "start   = {:?}", self.start)?;
        writeln!(f, "stop    = {:?}", self.stop)?;
        writeln!(f, "elapsed = {:?}", self.elapsed)?;
        Ok(())
    }
}

fn main() {
    fn work() -> Metrics<usize> {
        Metrics::gather(|| {
            let mut i: usize = 0;

            loop {
                if i == 1_000_000 { break; }
                i = i + 1;
            }
            i
        })
    }

    let handle = thread::spawn(work);
    let result1 = work();
    let result2 = handle.join().unwrap();
    println!("main\n{result1}");
    println!("spawned\n{result2}");
}

main
result  = 1000000
start   = SystemTime { tv_sec: 1737472310, tv_nsec: 712452124 }
stop    = SystemTime { tv_sec: 1737472310, tv_nsec: 714353146 }
elapsed = 1.900872ms

spawned
result  = 1000000
start   = SystemTime { tv_sec: 1737472310, tv_nsec: 712530206 }
stop    = SystemTime { tv_sec: 1737472310, tv_nsec: 714439057 }
elapsed = 1.908791ms

沙盒

如何将代码块放入 impl 中以创建单独的线程？

我看不懂措辞

请求的模块“del”不提供名为“default”的导出

"!+tab" 在 HTML 的 vs 代码中不起作用

我正在尝试解决“猜词”的问题。Python

可以使用哪些命令将当前指针移动到指定的提交而不更改工作目录中的文件？

Python解析野莓

问题：“警告：检查最新版本的 pip 时出错。”

帮助编写一个用值填充变量的循环。解决这个问题

尽管依赖数组为空，但在渲染上调用了 2 次 useEffect

数据不通过 Telegram.WebApp.sendData 发送

如何将代码块放入 impl 中以创建单独的线程？

1 个回答

相关问题