multithreading - 为什么我可以将 "move"静态 &str 放入 Rust 的多个线程中？

Question

我想更好地理解以下 Rust 代码背后的语义:

use std::thread;

fn main() {
    let immutable = "I am not mutable";
    let mut mutable = "I am mutable";

    let handle1 = thread::spawn(move || {
        println!("Thread 1 says: {}", immutable);
    });

    let handle2 = thread::spawn(move || {
        println!("Thread 2 says: {}", immutable);
    });

    let handle3 = thread::spawn(move || {
        println!("Thread 3 says: {}", mutable);
        mutable = "go away";
    });

    let handle4 = thread::spawn(move || {
        println!("Thread 4 says: {}", mutable);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

我不明白为什么这段代码可以编译。我在多个线程之间共享了变量 mutable 甚至改变了它。这里的内存到底发生了什么？我们是否在静态内存中制作了指向同一个字符串的多个指针？我们是否在内存中放置了两个不同的静态字符串？我可以让两个线程读取同一个不可变项这一事实并不让我感到惊讶，但让两个线程读取一个可变变量却让我感到惊讶。

请注意，即使线程 3 在 4 之前运行，4 也不会反射(reflect)线程 3 在其 println! 语句中设置的更新字符串。最后，因为我没有使用 &immutable，这是否意味着 value 被“移动”到每个线程而不是实际的内存地址？

Answer 1

I have shared the same variable mutable between multiple threads and even mutated it.

不，您已将对同一静态字符串的引用复制到多个线程中。引用指向一个不能改变的常量静态字符串。只读引用是 Copy，因此您可以将它们移动到多个闭包中。

What exactly is going on behind-the-scenes with the memory here?

字符串切片本质上是一个指针，指向内存中字符串的开头以及长度。你的变量mutable和immutable只包含这两条信息，对于mutable只有这两条信息是可变的。变量指向的实际字符串是不可变的。当将变量“移动”到闭包中时，它们实际上被复制了，因为 &str 是 Copy。唯一被复制的信息是指针和长度，而不是实际的字符串数据。您最终会得到指向同一个只读内存的多个指针，这不允许任何数据竞争并且符合 Rust 的内存安全规则。

Also, note that even if thread 3 runs before 4, 4 does not reflect the updated string that thread 3 sets in its println! statement.

你只修改指针的副本和长度。在线程 3 中，mutable 成为闭包本地的单独变量，您只需修改它即可。

Finally, since I didn't pass using &immutable, does this mean that the value is being "moved" into each thread rather than the actual memory address?

变量immutable的类型是&'static str，所以它已经是一个引用； &immutable 将是对引用的引用。