Rust の 所有権、借用、ライフタイムについて初心者目線で説明と整理を試みる

a = []
b = a
a.append(1)

>>> a
[1]
>>> b
[1]

let s1 = String::from("hello hello hello hello hello hello");
let s2 = s1;

let s1 = String::from("hello hello hello hello hello hello"");
let s2 = s1;
println!("{}, world!", s1);

error[E0382]: use of moved value: `s1`
              (ムーブされた値の使用: `s1`)
 --> src/main.rs:5:28
  |
3 |     let s2 = s1;
  |         -- value moved here
4 |
5 |     println!("{}, world!", s1);
  |                            ^^ value used here after move
  |                               (ムーブ後にここで使用されています)
  |
  = note: move occurs because `s1` has type `std::string::String`, which does
  not implement the `Copy` trait
    (注釈: ムーブが起きたのは、`s1`が`std::string::String`という
    `Copy`トレイトを実装していない型だからです)

fn main() {
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {}", r); //   |       |
                          // --+       |
}                         // ----------+

fn hoge(fuga: &str) {}

struct Hoge {
    hoge: &str,
}

struct Hoge<'a> {
    hoge: &'a str,
}

fn hoge(fuga: &str) {}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

{
        let r;                // ---------+-- 'a
                              //          |
        {                     //          |
            let x = 5;        // -+-- 'b  |
            r = &x;           //  |       |
        }                     // -+       |
                              //          |
        println!("r: {}", r); //          |
    }                         // ---------+

{
        let x = 5;            // ----------+-- 'b
                              //           |
        let r = &x;           // --+-- 'a  |
                              //   |       |
        println!("r: {}", r); //   |       |
                              // --+       |
    }                         // ----------+

fn main() {
    let mut data = 42;
    let immutable_ref = &data;
    let mutable_ref = &mut data; // エラー: 借用が生きている間は可変参照を作れない
    dbg!(immutable_ref);
}

fn main() {
  let mut data = 42;
{
    let immutable_ref = &data;
    dbg!(immutable_ref);
}

let mutable_ref = &mut data;
*mutable_ref += 1;
dbg!(mutable_ref);
}

pub trait Deref {
    type Target: ?Sized;

    // Required method
    fn deref(&self) -> &Self::Target;
}

use std::thread;

fn main() {
    let mut handles = vec![];
    let h1 = thread::spawn(move || loop {
        print!("1")
    });
    handles.push(h1);

    let h2 = thread::spawn(move || loop {
        print!("2")
    });
    handles.push(h2);

    for handle in handles {
        handle.join().unwrap();
    }
}

> cargo run
1111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111

use std::thread;

struct Data(i32);

fn main() {
    let cache = Data(0);

    thread::spawn(move || {
        cache;
    });

    thread::spawn(move || {
        cache;
    });
}

use of moved value: `cache`
value used here after moverustcClick for full compiler diagnostic
main.rs(9, 19): value moved into closure here
main.rs(10, 9): variable moved due to use in closure
main.rs(14, 9): use occurs due to use in closure
main.rs(7, 9): move occurs because `cache` has type `Data`, which does not implement the `Copy` trait
No quick fixes available

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

#[derive(Debug)]
struct Data(i32);

fn main() {
    let cache = Arc::new(Data(0));
    let mut handles = vec![];

    {
        let cache = Arc::clone(&cache);
        let handle = thread::spawn(|| {
            cache;
        });
        handles.push(handle)
    }

    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(|| {
            cache;
        });
        handles.push(handle)
    }

    for handle in handles {
        handle.join().unwrap();
    }

    dbg!(cache);
}

> cargo run
[src/main.rs:31] cache = Data(
    0,
)

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

#[derive(Debug)]
struct Data(i32);

fn main() {
    let cache = Arc::new(Data(0));
    let mut handles = vec![];

    {
        let cache = Arc::clone(&cache);
        let handle = thread::spawn(|| {
            cache.0 = cache.0 + 1;
        });
        handles.push(handle)
    }

    for handle in handles {
        handle.join().unwrap();
    }

    dbg!(cache);
}

rust_mutli_life::Data
0: i32 // size = 4, align = 4, offset = 0
cannot assign to data in an `Arc`
trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Arc<Data>`rustcClick for full compiler diagnostic

pub trait DerefMut: Deref {
    // Required method
    fn deref_mut(&mut self) -> &mut Self::Target;
}

use std::{
    ops::{Deref, DerefMut},
    sync::{Arc, Mutex},
    thread,
};

#[derive(Debug)]
struct Data<T>(T);

impl<T> Deref for Data<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for Data<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

fn main() {
    let cache = Arc::new(Data(0));
    let mut handles = vec![];
    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(move || {
            cache.0 += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    dbg!(cache);
}

cannot assign to data in an `Arc`
trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Arc<Data<i32>>`rustcClick for full compiler diagnostic

use std::{
    cell::UnsafeCell,
    ops::{Deref, DerefMut},
    sync::Arc,
    thread,
};

#[derive(Debug)]
struct Data<T>(UnsafeCell<T>);

impl<T> Deref for Data<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0.get() }
    }
}

impl<T> DerefMut for Data<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *self.0.get() }
    }
}

fn main() {
    let cache = Arc::new(Data(UnsafeCell::new(0)));
    let mut handles = vec![];
    {
        let cache = Arc::clone(&cache);
        let handle = thread::spawn(move || {
            unsafe { *cache.0.get().as_mut().unwrap() = *cache.0.get() + 1 };
        });
        handles.push(handle);
    }

    {
        let cache = Arc::clone(&cache);
        let handle = thread::spawn(move || {
            unsafe { *cache.0.get().as_mut().unwrap() = *cache.0.get() + 1 };
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        let value = &*cache.0.get();
        println!("Value: {}", value);
    };
}

`UnsafeCell<i32>` cannot be shared between threads safely
within `Data<i32>`, the trait `Sync` is not implemented for `UnsafeCell<i32>`
required for `Arc<Data<i32>>` to implement `Send`

pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
    Builder::new().spawn(f).expect("failed to spawn thread")
}

use std::{
    cell::UnsafeCell,
    ops::{Deref, DerefMut},
    sync::Arc,
    thread,
};

#[derive(Debug)]
struct Data<T>(UnsafeCell<T>);

impl<T> Deref for Data<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0.get() }
    }
}

impl<T> DerefMut for Data<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *self.0.get() }
    }
}

unsafe impl<T> Send for Data<T> {}
unsafe impl<T> Sync for Data<T> {}

fn main() {
    let cache = Arc::new(Data(UnsafeCell::new(0)));
    let mut handles = vec![];
    {
        let cache = Arc::clone(&cache);
        let handle = thread::spawn(move || {
            unsafe { *cache.0.get().as_mut().unwrap() = *cache.0.get() + 1 };
        });
        handles.push(handle);
    }

    {
        let cache = Arc::clone(&cache);
        let handle = thread::spawn(move || {
            unsafe { *cache.0.get().as_mut().unwrap() = *cache.0.get() + 1 };
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        let value = &*cache.0.get();
        println!("Value: {}", value);
    };
}

❯ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/rust-mutli-life`
Value: 2

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> Deref for MutexGuard<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
        unsafe { &*self.lock.data.get() }
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
    fn deref_mut(&mut self) -> &mut T {
        unsafe { &mut *self.lock.data.get() }
    }
}

pub struct MutexGuard<'a, T: ?Sized + 'a> {
    lock: &'a Mutex<T>,
    poison: poison::Guard,
}

pub struct Mutex<T: ?Sized> {
    inner: sys::MovableMutex,
    poison: poison::Flag,
    data: UnsafeCell<T>,
}

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Send> Send for Mutex<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}

#[stable(feature = "rust1", since = "1.0.0")]
    pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
        unsafe {
            self.inner.raw_lock();
            MutexGuard::new(self)
        }
    }

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

#[derive(Debug)]
struct Data(i32);

fn main() {
    let cache = Arc::new(Mutex::new(Data(0)));
    let mut handles = vec![];
    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(move || {
            let mut guard = cache.lock().unwrap();
            guard.0 = guard.0 + 1;
        });
        handles.push(handle);
    }

    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(move || {
            let mut guard = cache.lock().unwrap();
            guard.0 = guard.0 + 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    dbg!(cache);
}

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

#[derive(Debug)]
struct Data(i32);

fn main() {
    let cache = Arc::new(Mutex::new(Data(0)));
    let mut handles = vec![];
    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(move || {
            let mut guard = cache.lock().unwrap();
            guard.0 = guard.0 + 1;
        });
        handles.push(handle);
    }

    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(move || {
            let mut guard = cache.lock().unwrap();
            guard.0 = guard.0 + 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    dbg!(cache);
}

    {
        let cache = Arc::clone(&cache);

        let handle = thread::spawn(|| {
            let mut guard = cache.lock().unwrap();
            guard.0 = guard.0 + 1;
        });
        handles.push(handle);
    }

{closure#6} // size = 8, align = 8
impl Fn()
Captures
cache by immutable borrow
to force the closure to take ownership of `cache` (and any other referenced variables), use the `move` keyword: `move `rustcE0373
main.rs(15, 36): original diagnostic
closure may outlive the current function, but it borrows `cache`, which is owned by the current function
may outlive borrowed value `cache`rustcClick for full compiler diagnostic

pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
    Builder::new().spawn(f).expect("failed to spawn thread")
}

pub trait Fn<Args>: FnMut<Args> {
    /// Performs the call operation.
    #[unstable(feature = "fn_traits", issue = "29625")]
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

pub trait FnMut<Args>: FnOnce<Args> {
    /// Performs the call operation.
    #[unstable(feature = "fn_traits", issue = "29625")]
    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}

pub trait FnOnce<Args> {
    /// The returned type after the call operator is used.
    #[lang = "fn_once_output"]
    #[stable(feature = "fn_once_output", since = "1.12.0")]
    type Output;

    /// Performs the call operation.
    #[unstable(feature = "fn_traits", issue = "29625")]
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

struct Closure {
  data: &T
}

struct Closure {
  data: T
}

let data = vec![1, 2, 3];
let closure = move || println!("captured {data:?} by value");

// data is no longer available, it is owned by the closure

use std::{rc::Rc, sync::Mutex, thread};

#[derive(Debug)]
struct Data(i32);

fn main() {
    let cache = Rc::new(Mutex::new(Data(0)));
    let mut handles = vec![];
    {
        let cache = Rc::clone(&cache);

        let handle = thread::spawn(move || {
            let mut guard = cache.lock().unwrap();
            guard.0 = guard.0 + 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    dbg!(cache);
}

`Rc<Mutex<Data>>` cannot be sent between threads safely
within `[closure@src/main.rs:12:36: 12:43]`, the trait `Send` is not implemented for `Rc<Mutex<Data>>`rustcClick for full compiler diagnostic
main.rs(12, 36): within this `[closure@src/main.rs:12:36: 12:43]`
main.rs(12, 22): required by a bound introduced by this call
main.rs(12, 36): required because it's used within this closure
mod.rs(662, 8): required by a bound in `spawn`
No quick fixes available

#[stable(feature = "rust1", since = "1.0.0")]
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
    Builder::new().spawn(f).expect("failed to spawn thread")
}

unsafe impl<T> Send for Data<T> {}
unsafe impl<T> Sync for Data<T> {}

the trait `Send` requires an `unsafe impl` declarationrustcClick for full compiler diagnostic
No quick fixes available

pub unsafe auto trait Send {
    // empty.
}