相关疑难解决方法(0)

我无法在线程之间共享引用.

trait Facade { /*some functions*/ }

struct Client<'a> {
    facade: &'a mut Facade,
    join_grd: thread::JoinGuard<'a()>,
}

impl<'a> Client<'a> {
    pub fn new(my_facade: &'a mut Facade) -> Client<'a> {
        Client {
            facade: my_facade,
        join_grd: thread::scoped(|| Client::start(my_facade)),
        }
    }

    fn start(my_facade: &'a mut Facade) { unimplemented!() }
}

鉴于我在Rust中的新手状态,我对概念和错误感到困惑.我如何实现上述目标？

我想.zip使用zip crate读取不同线程中的文件。

extern crate zip;

use zip::ZipArchive;
use zip::read::ZipFile;
use std::fs::File;
use std::io::BufReader;
use std::thread;

fn compute_hashes(mut file: ZipFile) {
    let reader_thread= thread::spawn(move || {
        let mut reader = BufReader::new(file);
        /* ... */
    });
}

fn main() {
    let mut file = File::open(r"facebook-JakubOnderka.zip").unwrap();
    let mut zip = ZipArchive::new(file).unwrap();

    for i in 0..zip.len() {
        let mut inside = zip.by_index(i).unwrap();

        if !inside.name().ends_with("/") { // skip directories
            println!("Filename: {}", inside.name());
            compute_hashes(inside);
        }
    }
}

但是编译器向我显示此错误：

extern crate zip;

use …

我有一些可变的状态,我需要在线程之间共享.我按照Rust书的并发部分,它在线程之间共享一个向量并对其进行变异.

我需要共享最终单形化的通用结构,而不是向量.这是我正在尝试的一个提炼的例子:

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use std::marker::PhantomData;

trait Memory {}

struct SimpleMemory;

impl Memory for SimpleMemory {}

struct SharedData<M: Memory> {
    value: usize,
    phantom: PhantomData<M>,
}

impl<M: Memory> SharedData<M> {
    fn new() -> Self {
        SharedData {
            value: 0,
            phantom: PhantomData,
        }
    }
}

fn main() {
    share(SimpleMemory);
}

fn share<M: Memory>(memory: M) {
    let data = Arc::new(Mutex::new(SharedData::<M>::new()));

    for i in 0..3 {
        let data = data.clone();
        thread::spawn(move || {
            let mut data = …

我正在尝试存储我的应用程序的状态，其中包括在开始时初始化并在多个线程之间传递状态的特征列表，但出现错误。

use std::sync::{Arc, RwLock};
use std::thread;
use std::time::Duration;

trait TestTrait {
    fn test(&self);
}

struct MyTestStruct {}

impl TestTrait for MyTestStruct {
    fn test(&self) {
        println!("Test trait called");
    }
}

struct DataStore {
    t: Box<dyn TestTrait>,
}

fn main() {
    let s = Arc::new(RwLock::new(DataStore {
        t: Box::new(MyTestStruct {}),
    }));
    let s_clone = s.clone();
    thread::spawn(move || {
        for i in 1..10 {
            s_clone.read().unwrap().t.test();
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number …