如何在Rust中实现I2C总线的线程安全访问？

更新：根据@ChayimFriedman的评论，已将lazy_static替换为once_cell::sync::Lazy。

我用rppal::gpio结合std::sync::{Arc,Mutex}实现了树莓派GPIO资源的线程安全访问，但给rppal::i2c做同样操作时遇到问题：Arc需要的clone方法是rppal::i2c未提供的，导致代码无法编译。

问题代码如下：

use once_cell::sync::Lazy;
use rppal::i2c::{I2c,Error};
use std::sync::{Arc, Mutex};

const I2C_BUS: u8 = 1; // 树莓派上的I2C总线编号
static GLOBAL_I2C: Lazy<Arc<Mutex<Option<I2c>>>> = Lazy::new(||
    {
        Arc::new(Mutex::new(None))
    }
);


fn initialize_i2c(bus: u8) -> Result<I2c, Error> {
    I2c::with_bus(bus)
}

pub fn access_or_initialize_i2c() -> Result<I2c, Error> {
    let binding = GLOBAL_I2C.clone();
    // 锁定互斥锁以访问I2c
    let mut guard = match binding.lock() {
        Ok(g) => g,
        Err(e) => {
            // 并非真的线程panic，只是示例代码
            return Err(Error::Io(std::io::Error::new(std::io::ErrorKind::Other, "Not really a thread panic.")))
        }
    };

    // 检查I2c是否已初始化
    if guard.is_none() {
        // 延迟初始化I2c
        match initialize_i2c(I2C_BUS) {
            Ok(initialized_i2c) => *guard = Some(initialized_i2c),
            Err(e) => {
                return Err(e)
            }
        }
    }

    // 返回I2c实例
    match guard.as_ref() {
        // 问题出在这里
        // 
        //     --> src/i2c.rs:38:34
        //     |
        //  39 |         Some(i2c_instance) => Ok(i2c_instance.clone()),
        //     |                               -- ^^^^^^^^^^^^^^^^^^^^ expected `I2c`, found `&I2c`
        //     |                               |
        //     |                               arguments to this enum variant are incorrect
        //     |
        //  note: `I2c` does not implement `Clone`, so `&I2c` was cloned instead
        Some(i2c_instance) => Ok(i2c_instance.clone()),
        None => {
            // 并非真的线程panic，只是示例代码
            Err(Error::Io(std::io::Error::new(std::io::ErrorKind::Other, "Not really a thread panic.")))
        }
    }
}

我期望的使用方式：

match i2c::access_or_initialize_i2c() {
    Ok(i2c) => {
        i2c.set_slave_address(device_address);
        i2c.read(buf); // 或者 i2c.write(buf); 
    }
    Err(e)  => { ... }
}

解决方案 #

核心问题是I2c类型不实现Clone——它对应物理硬件资源，不能直接复制实例。正确的做法不是返回I2c本身，而是通过锁机制保证同一时间只有一个线程访问硬件，以下是两种可行方案：

方案1：返回锁守卫，让调用者在锁生命周期内操作 #

修改函数返回类型为MutexGuard，调用者通过守卫访问内部的I2c，确保锁在操作期间始终持有：

use once_cell::sync::Lazy;
use rppal::i2c::{I2c,Error};
use std::sync::{Arc, Mutex, MutexGuard};

const I2C_BUS: u8 = 1;
static GLOBAL_I2C: Lazy<Arc<Mutex<Option<I2c>>>> = Lazy::new(|| Arc::new(Mutex::new(None)));

fn initialize_i2c(bus: u8) -> Result<I2c, Error> {
    I2c::with_bus(bus)
}

pub fn access_or_initialize_i2c() -> Result<MutexGuard<'static, Option<I2c>>, Error> {
    let binding = GLOBAL_I2C.clone();
    let mut guard = binding.lock().map_err(|e| {
        Error::Io(std::io::Error::new(std::io::ErrorKind::Other, format!("Mutex poisoned: {}", e)))
    })?;

    if guard.is_none() {
        let initialized_i2c = initialize_i2c(I2C_BUS)?;
        *guard = Some(initialized_i2c);
    }

    Ok(guard)
}

调整后的使用方式：

match i2c::access_or_initialize_i2c() {
    Ok(mut guard) => {
        if let Some(i2c) = guard.as_mut() {
            i2c.set_slave_address(device_address);
            i2c.read(buf).unwrap();
        }
    }
    Err(e) => {
        eprintln!("I2C访问失败: {}", e);
    }
}

方案2：封装操作闭包，隐藏锁细节 #

如果不想让调用者直接处理锁守卫，可以封装一个函数，接收闭包来操作I2c，锁的获取和释放由函数内部处理：

use once_cell::sync::Lazy;
use rppal::i2c::{I2c,Error};
use std::sync::{Arc, Mutex};

const I2C_BUS: u8 = 1;
static GLOBAL_I2C: Lazy<Arc<Mutex<Option<I2c>>>> = Lazy::new(|| Arc::new(Mutex::new(None)));

fn initialize_i2c(bus: u8) -> Result<I2c, Error> {
    I2c::with_bus(bus)
}

pub fn with_i2c<F, R>(f: F) -> Result<R, Error>
where
    F: FnOnce(&mut I2c) -> R,
{
    let binding = GLOBAL_I2C.clone();
    let mut guard = binding.lock().map_err(|e| {
        Error::Io(std::io::Error::new(std::io::ErrorKind::Other, format!("Mutex poisoned: {}", e)))
    })?;

    let i2c = guard.get_or_insert_with(|| initialize_i2c(I2C_BUS).unwrap());
    Ok(f(i2c))
}

使用方式更简洁：

match i2c::with_i2c(|i2c| {
    i2c.set_slave_address(device_address);
    i2c.read(buf)
}) {
    Ok(_) => println!("读取成功"),
    Err(e) => eprintln!("I2C错误: {}", e),
}

关键说明 #

物理硬件资源（如I2C总线）是独占性的，同一时间只能有一个线程操作。如果允许复制I2c实例，会导致多线程同时操作硬件，引发不可预测的行为。通过Mutex守卫或闭包封装，能保证同一时间只有一个线程访问硬件，实现真正的线程安全。

内容的提问来源于stack exchange，提问作者Jamie