Send 只能针对 struct/enum 类型实现，而不能针对 Trait 实现

Question

我很难实现Send某个特质。完整代码在操场上。

我有一个Storage特点：

pub trait Storage {
    fn get_value(&self, key: &str) -> Result<Vec<u8>, Error>;
    fn put_value(&mut self, key: &str, value: &[u8]) -> Result<(), Error>;
    fn key_exists(&self, key: &str) -> bool;
    fn delete_key(&mut self, key: &str) -> Result<(), Error>;
}

它是Consistency结构的一部分：

pub struct Consistency<'a> {
    storage: &'a mut Storage,
}

我已经实现了一个MemoryStorage结构：

#[derive(Debug)]
struct MemoryStorage {
    data: HashMap<String, Vec<u8>>,
}

impl Storage for MemoryStorage {
    fn get_value(&self, key: &str) -> Result<Vec<u8>, Error> {
        self.data.get(key).map_or(
            Err(Error::new(ErrorKind::NotFound, "Key does not exists")),
            |v| Ok(v.clone()),
        )
    }

    fn put_value(&mut self, key: &str, value: &[u8]) -> Result<(), Error> {
        self.data.insert(key.to_string(), Vec::from(value));
        Ok(())
    }

    fn key_exists(&self, key: &str) -> bool {
        self.data.contains_key(key)
    }

    fn delete_key(&mut self, key: &str) -> Result<(), Error> {
        self.data.remove(key).map_or(
            Err(Error::new(ErrorKind::NotFound, "Key does not exists")),
            |v| Ok(()),
        )
    }
}

我写了一个测试：

#[test]
fn multiple_threads_bombing_storage() {
    const parallels: usize = 10;
    let mut storage = MemoryStorage {
        data: HashMap::new(),
    };
    let mut consistency = Consistency::new(&mut storage);

    // create all keys.
    let mut keys = Vec::<String>::new();
    for k in 1..parallels {
        keys.push(k.to_string());
    }

    let zero = "0".as_bytes();
    // put default values in files.
    for key in keys.clone() {
        consistency.put_value(&key, zero).unwrap();
    }

    // test write threads
    let write_thread = |to_write: Vec<u8>, keys: &mut Vec<String>| {
        let mut rng = rand::thread_rng();
        rng.shuffle(keys);

        for key in keys {
            let mut val = consistency.get_value(key).unwrap();
            val.append(to_write.clone().as_mut());
            consistency.put_value(key, &val).unwrap();
        }
    };

    // start parallels threads..
    for t in 1..parallels {
        let handle = thread::spawn(move || {
            write_thread(t.to_string().into_bytes(), &mut keys);
        });
    }

    // wait for all threads..

    // check if all parallels keys have all numbers in any order.
}

这给了我一个错误：

pub trait Storage {
    fn get_value(&self, key: &str) -> Result<Vec<u8>, Error>;
    fn put_value(&mut self, key: &str, value: &[u8]) -> Result<(), Error>;
    fn key_exists(&self, key: &str) -> bool;
    fn delete_key(&mut self, key: &str) -> Result<(), Error>;
}

添加unsafe impl Send for Storage {}给了我一个矛盾的错误，Send无法针对特征实现：

pub struct Consistency<'a> {
    storage: &'a mut Storage,
}

我不明白如何解决这个问题。

Answer 1

您有对实现特征的事物的引用（特征对象）的对象的引用，但不能保证您的特征能够在线程之间发送。

您需要确保它是。您可以要求您的特质的所有实现者是Send：

pub trait Storage: Send {
    // ...
}

或者这个特定的特征对象实现Send：

pub struct Consistency<'a> {
    storage: &'a mut (Storage + Send),
}

您的代码还有许多其他问题，因此仍然无法编译。他们之中：

1. 您尝试将堆栈分配的变量传递给线程。
2. 您尝试在多个线程之间共享可变引用。

您可能需要回去重新阅读《Rust 编程语言》，尤其是有关并发的章节。

也可以看看：

• 我可以有一个对特征对象的静态借用引用吗？
• 如何将对堆栈变量的引用传递给线程？
• 在线程之间共享可变对象