设计帮助：在结构中进行线程化

Question

我是Rust的新手。 作为一个学习练习，我正在尝试编写一个我曾用C ++编写的简单计时器结构。 接口和实现看起来像这样：

pub struct Timer {
    handle: Option<std::thread::JoinHandle<()>>,
    alive: bool,
}

impl Timer {
    pub fn new() {
        Timer {
            handle: None,
            alive: false,
        }
    }

    pub fn start(&'static mut self) {
        // Oops! How do I do this?
        self.handle = Some(std::thread::spawn(move || {
            self.alive = true;
            self.loop()
        }));
    }

    pub fn stop(&mut self) {
        self.alive = false;
        self.handle.unwrap().join()
    }

    pub fn loop(&self) {
        // while alive
    }
}

我理解为什么这是一个错误，因为在start函数中use of moved value: self ，但我想知道我应该如何设计我的结构，以便这样的东西可以工作。 在我能想到的每一个场景中，我总会有双重借款的情况。

我有一种预感，我需要更多地了解内部可变性，但我想在再下一个兔子洞之前我会要求设计指导。

Answer 1

我认为你非常接近它的工作。

只有两个障碍：

• thread::spawn不允许共享引用
• alive ， loop让你分享这个设计

解决方案有两个方面：

• 拆分控制器（ Timer ）和worker（闭包）之间的东西
• 使用Arc共享两者之间的状态，因为禁止引用

这是一个玩具的最小例子：

use std::{sync, thread, time};
use std::sync::atomic::{AtomicBool, Ordering};

pub struct Timer {
    handle: Option<thread::JoinHandle<()>>,
    alive: sync::Arc<AtomicBool>,
}

impl Timer {
    pub fn new() -> Timer {
        Timer {
            handle: None,
            alive: sync::Arc::new(AtomicBool::new(false)),
        }
    }

    pub fn start<F>(&mut self, fun: F)
        where F: 'static + Send + FnMut() -> ()
    {
        self.alive.store(true, Ordering::SeqCst);

        let alive = self.alive.clone();

        self.handle = Some(thread::spawn(move || {
            let mut fun = fun;
            while alive.load(Ordering::SeqCst) {
                fun();
                thread::sleep(time::Duration::from_millis(10));
            }
        }));
    }

    pub fn stop(&mut self) {
        self.alive.store(false, Ordering::SeqCst);
        self.handle
            .take().expect("Called stop on non-running thread")
            .join().expect("Could not join spawned thread");
    }
}

fn main() {
    let mut timer = Timer::new();
    timer.start(|| println!("Hello, World!") );

    println!("Feeling sleepy...");
    thread::sleep(time::Duration::from_millis(100));

    println!("Time for dinner!");
    timer.stop();
}

我邀请你一次戳一个洞（即，改变一个与你的例子不同的东西，检查错误信息，并尝试理解差异如何解决它）。

在操场上，它为我打印：

Feeling sleepy...
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Time for dinner!

虽然我不会依赖（1） "Hello, World!"的次数"Hello, World!" 出现和（2） "Feeling sleepy..."首先出现。

该死的，是Atomic verbose ...我有点希望有一个get / set SeqCst （强大的排序）可用。