小编swi*_*ard的帖子

我想从一个受a保护的函数返回一个值Mutex,但是无法理解如何正确地执行它.此代码不起作用:

use std::sync::{Arc, Mutex};

fn func() -> Result<(), String> {
    let result_my = Arc::new(Mutex::new(Ok(())));
    let result_his = result_my.clone();

    let t = std::thread::spawn(move || {
        let mut result = result_his.lock().unwrap();
        *result = Err("something failed".to_string());
    });

    t.join().expect("Unable to join thread");

    let guard = result_my.lock().unwrap();
    *guard
}

fn main() {
    println!("func() -> {:?}", func());
}

操场

编译器抱怨:

error[E0507]: cannot move out of borrowed content
  --> src/main.rs:16:5
   |
16 |     *guard
   |     ^^^^^^ cannot move out of borrowed content

我无法弄清楚为什么这段代码会编译:

fn f(v: &mut Vec<isize>) -> &[isize] {
    v.as_mut_slice()
}

这不是:

fn f(v: &mut Vec<isize>) -> &[isize] {
    v.as_slice()
}

生产:

<anon>:2:5: 2:6 error: `v` does not live long enough
<anon>:2     v.as_slice()
             ^
<anon>:1:38: 3:2 note: reference must be valid for the anonymous lifetime #1 defined on the block at 1:37...
<anon>:1 fn f(v: &mut Vec<isize>) -> &[isize] {
<anon>:2     v.as_slice()
<anon>:3 }
<anon>:1:38: 3:2 note: ...but borrowed value is only valid for the block at 1:37
<anon>:1 fn f(v: …

编译器允许我编写如下函数的全面实现：

trait Invoke {
    type S;
    type E;

    fn fun(&mut self) -> Result<Self::S, Self::E>;
}

impl<F, S, E> Invoke for F
where
    F: Fn() -> Result<S, E>,
{
    type S = S;
    type E = E;

    fn fun(&mut self) -> Result<S, E> {
        self()
    }
}

但是当我尝试添加函数参数时它开始抱怨：

trait Invoke {
    type A;
    type S;
    type E;

    fn fun(&mut self, arg: Self::A) -> Result<Self::S, Self::E>;
}

impl<F, A, S, E> Invoke for F
where
    F: Fn(A) -> Result<S, E>,
{
    type …

T我有一些既不实现也不实现的Copy数据类型Clone。

1. 如果我想在多个线程之间不可变地共享数据，我将使用Arc<T>.
2. 如果我想可变地共享它，我会使用Arc<Mutex<T>>.

如果我想先可变地共享它，然后在循环中不变地共享它怎么办？所以：

• 我不能使用Arc<T>or ，Arc<Mutex<Arc<T>>>因为我无法改变“可变”线程中的数据。
• 我可以使用Arc<Mutex<T>>，但随后我必须lock()在每个“不可变”线程中使用它才能达到T，从而失去并行性。
• 突变完成后我无法复制数据，因为它很昂贵（或者没有办法实现Clone）。

那么什么是正确有效的解决方案呢？

我试图制作某种解码器,只需将值映射到某些内存区域,就可以在不实际复制内存的情况下对条目进行反序列化.这就是我目前设法做的事情(简化为testcase):

#![allow(unstable)]

trait CastAbility: Sized { }
impl CastAbility for u64 { }
impl CastAbility for u32 { }
impl CastAbility for u16 { }
impl CastAbility for u8 { }

trait Cast {
    fn cast<'a>(mem: &'a [u8]) -> Result<&'a Self, String>;
}

impl<T> Cast for T where T: CastAbility {
    fn cast<'a>(mem: &'a [u8]) -> Result<&'a T, String> {
        if mem.len() != std::mem::size_of::<T>() { 
            Err("invalid size".to_string())
        } else {
            Ok(unsafe { std::mem::transmute(mem.as_ptr()) })
        }
    }
}

impl Cast for …

我试图通过组合os::MemoryMap和fs::File某种RAII样式来实现内存映射文件.请考虑以下示例:

#![feature(fs, os, io, path, std_misc, core)]

use std::{io, os, mem, raw};
use std::io::{Seek};
use std::fs::{File};
use std::path::{Path};
use std::os::{MemoryMap};
use std::borrow::{Cow};
use std::error::{FromError};
use std::os::unix::{AsRawFd};

struct Mmapped {
    file: File,
    map: MemoryMap,
    map_len: usize,
}

#[derive(Debug)]
enum Error {
    IoError(io::Error),
    MmapError(os::MapError),
}

impl FromError<io::Error> for Error { 
    fn from_error(err: io::Error) -> Error { Error::IoError(err) }
}

impl FromError<os::MapError> for Error { 
    fn from_error(err: os::MapError) -> Error { Error::MmapError(err) }
}

impl Mmapped {
    fn new(filename: …