在结构实现中为循环单独线程

Question

我正在使用一个结构，我需要在其中读取 Raspberry Pi 的 GPIO 引脚，并在每次引脚变高时在结构中增加一个“寄存器”。 与此同时，我希望能够时不时地对寄存器进行采样，看看当前值是多少。

在实现这一点时，我的想法是生成一个线程，该线程不断循环检查引脚是否从低电平变为高电平，并从线程内递增寄存器。 然后，从父线程，我可以读取寄存器的值并报告它。

在做了一些研究之后，似乎一个作用域线程不会是这个的正确实现，因为子线程永远不会将寄存器的所有权移交给父线程。

相反，我相信我应该使用 Arc/Mutex 组合来保护寄存器，并且只是暂时控制锁以增加寄存器。 这是Rust中多线程的正确解释吗？

假设以上是正确的，我不确定如何在 Rust 中实现它。

struct GpioReader {
    register: Arc<Mutex<i64>>,
    input_pin: Arc<Mutex<InputPin>>,
}

impl GpioReader {
    pub fn new(input_pin: InputPin) -> Self {
        Self {
            register: Arc::New(Mutex::from(0)),
            input_pin: Arc::new(Mutex::from(input_pin))
        }
    }

    pub fn start(&self) {
        let pin = self.input_pin.lock().unwrap(); // ???
        let register = self.register.lock().unwrap(); // ???

        let handle = spawn(move || loop {
            match pin.read() { // ???
                High => register += 1, // ???
                Low => (),
            }

            sleep(Duration::from_millis(SLEEP_TIME));
        });
        handle.join().expect("Failed to join thread.");
    }

    pub fn get_register(&self) -> i64 {
        let reg_val = self.register.lock().unwrap();

        return reg_val;
    }
}

鉴于上述情况，我如何声明pin和register变量，以便我可以读取引脚并在循环内递增寄存器？ 我最好的猜测是我必须在循环之外实例化对结构的这些成员的某种引用，然后将引用传递到循环中，此时我可以使用 Arc 的lock()方法。

编辑：使用运行 Raspbian 的 RaspberryPi 3A+。 有问题的InputPin来自rppal crate 。

Answer 1

• Mutex<i64>是一种反模式。 将其替换为AtomicI64 。
• Arc旨在使用Arc::clone()进行克隆，以创建对相同 object 的新引用。
• 如无必要，不要使用共享所有权。 InputPin仅在线程内使用，因此请将其移入。
• 我不确定你为什么做handle.join() 。 如果你想让它在后台继续，不要用.join()等待它。

use std::{
    sync::{
        atomic::{AtomicI64, Ordering},
        Arc,
    },
    thread::{self, sleep},
    time::Duration,
};

use rppal::gpio::InputPin;

struct GpioReader {
    register: Arc<AtomicI64>,
    input_pin: Option<InputPin>,
}

const SLEEP_TIME: Duration = Duration::from_millis(1000);

impl GpioReader {
    pub fn new(input_pin: InputPin) -> Self {
        Self {
            register: Arc::new(AtomicI64::new(0)),
            input_pin: Some(input_pin),
        }
    }

    pub fn start(&mut self) {
        let register = Arc::clone(&self.register);
        let pin = self.input_pin.take().expect("Thread already running!");

        let handle = thread::spawn(move || loop {
            match pin.read() {
                High => {
                    register.fetch_add(1, Ordering::Relaxed);
                }
                Low => (),
            }

            sleep(SLEEP_TIME);
        });
    }

    pub fn get_register(&self) -> i64 {
        self.register.load(Ordering::Relaxed)
    }
}

---

如果你想在GpioReader object 被丢弃时自动停止线程，你可以使用Weak k 向线程发出信号：

use std::{
    sync::{
        atomic::{AtomicI64, Ordering},
        Arc,
    },
    thread::{self, sleep},
    time::Duration,
};

use rppal::gpio::InputPin;

struct GpioReader {
    register: Arc<AtomicI64>,
    input_pin: Option<InputPin>,
}

const SLEEP_TIME: Duration = Duration::from_millis(1000);

impl GpioReader {
    pub fn new(input_pin: InputPin) -> Self {
        Self {
            register: Arc::new(AtomicI64::new(0)),
            input_pin: Some(input_pin),
        }
    }

    pub fn start(&mut self) {
        let register = Arc::downgrade(&self.register);
        let pin = self.input_pin.take().expect("Thread already running!");

        let handle = thread::spawn(move || loop {
            if let Some(register) = register.upgrade() {
                match pin.read() {
                    High => {
                        register.fetch_add(1, Ordering::Relaxed);
                    }
                    Low => (),
                }

                sleep(SLEEP_TIME);
            } else {
                // Original `register` got dropped, cancel the thread
                break;
            }
        });
    }

    pub fn get_register(&self) -> i64 {
        self.register.load(Ordering::Relaxed)
    }
}