advance/concurrency-with-threads/send-sync

[giscus[bot]]

advance/concurrency-with-threads/send-sync

https://course.rs/advance/concurrency-with-threads/send-sync.html

[zhangdekui]

unsafe impl Sync for MyBox {}
这行代码什么逻辑都没有, 只是声明了一下, 为什么就能工作呢???
难道只是单纯的为了取悦编译器吗?

[cuitaocrazy]

如果仅仅是兑付一下编译器，你可以这么说。如果是真实的环境，rust并不知道MyBox在线程共享时安全，因此这个安全性需要你自己来保证，如果你认为是线程安全的，你就标记这个特质。就像上面文档“总结”部分第二点提到的Cell，在rust标准库中Cell明确标记impl<T: ?Sized> !Sync for Cell<T> {}，因为rust认为Cell这个东西线程是不安全的，你不能在多线程中用直接用Cell.

[lifei6671]

也就是说，如果声明了这个特征，但是实际上并没有实现线程安全，那么能够编译过，但是运行的时候可能出现panic？

[jinmingzhuo]

问了问gpt

对于 unsafe impl Sync for MyBox {} 这样的代码，它实际上是在告诉编译器：“我知道这个类型 (MyBox in this case) 是 Sync 的，即它可以在多个线程之间安全地共享，尽管编译器无法验证这一点。”

这可能是因为实际上 MyBox 类型的实现确实是安全的，或者因为程序员在使用这个类型时会采取额外的措施来确保线程安全性。在这种情况下，使用 unsafe 是一种在代码中做出显式声明的方式，表示程序员自己负责确保线程安全，而编译器无法提供静态检查。

在 Rust 中，unsafe 关键字允许绕过编译器的某些安全检查，包括对多线程安全性的检查。如果你使用 unsafe 声明了一个类型实现了 Sync 特性，但是实际上它并不是线程安全的，那么编译器将接受这个声明，但在运行时可能会出现潜在的线程安全问题，导致 panic 或其他未定义行为。

[Tom-Jim]

相当于自己担责而不是编译器负责{}内的代码，还有不能实现特征还敢用unsafe？

[lf-wxp]

若类型 T 的引用&T是Send，则T是Sync。 这个结论感觉有点绕，能帮忙解释一下吗？

[yurnery]

官方的文档意思是 当且仅当 &T 是 Send 的时候 T 才是 Sync 的。

[ADkun]

内部应该是有：
impl Send for &T where T: Sync {}
当T实现了Sync，编译器会自动为&T实现Send

实现上看，是从T: Sync推出&T: Send
而理论上看，T: Sync和&T: Send是互推的，实现了一个另一个也成立

[ADkun]

更正一下我的说法：
impl Send for &T where T: Sync {}
当T实现了Sync，编译器会自动为&T实现Send
这是因为，T实现Sync说明它可以在多线程之间安全地共享+安全地并发访问。
但反过来&T: Send并不能推出T: Sync，因为&T: Send仅仅说明T的不可变引用可以在多个线程之间传递，并不能说明T能够在多线程之间安全地并发使用。

[supalle]

看前面的那一句：

这里还有一个潜在的依赖：一个类型要在线程间安全的共享的前提是，指向它的引用必须能在线程间传递。因为如果引用都不能被传递，我们就无法在多个线程间使用引用去访问同一个数据了。

简而言之：Send 是 Sync 的前提，也就是，传递是共享的前提。

而共享是通过引用去共享的，那么如果一个类型 T 的引用 &T 是能传递的，说明类型 T 是可以能共享的。

[Pro741]

这里我用堆栈举个例子, 如果一个变量存储在堆上, 在单线程中, 我们怎么样才能访问到这个堆上的数据?

• 答案显而易见, 是将这个堆上数据的地址(指针)存在栈上, 我们利用栈上的这个地址访问堆上数据.

现在变到多线程了! 有很多线程都想访问这个数据, 怎么办?

• 我们只需要把这个堆上数据的地址(指针)拷贝存不同线程的栈上, 这样这些线程就能访问到这个数据了

这就是数据共享, 共享的本质就是它的指针/引用能够"发送"到不同线程上, 所以 T: Sync 就表示 T 这个变量的引用 &T: Send (有点不规范, 但是这个意思).

再说下那两个例子, 首先, RwLock<T> 和 Mutex<T> 都是实现了Sync的, 只是对结构体中包裹的字段T类型有不一样的限制. RwLock 允许多个线程同时获得T的不可变引用,那T必定要实现Sync, 而Mutex就没有这个要求了, 所以它的字段是否实现Sync就无关紧要了

[Ryu2u]

有个关于裸指针转换的问题
5 as *const i32 和 &5 as *const i32有什么区别呢?
前者即使在使用了unsafe的情况下也无法正常读取出裸指针中的数值
例如

let p = 6 as *const i32;
        unsafe{
            let n = *p;
            println!("{}", n);
        }

上面这段代码是无法运行的

[aa1ss2]

5是非法内存地址,直接用5作为指针当然崩了,改成

    let p = 0x00000000004016f0 as *const i64;
    unsafe{
        let n = *p;
        println!("{:x}", n);
    }

就可以了

[yxxuweb]

你应该去看看 as 的用法

[478619644h]

无中生有 & 探囊取物

[einQimiaozi]

请教下，实现Sync智能指针的那部分代码为什么这样实现会在Mutex::new的地方报错 borrowed value does not live long enough

let b = MyBox(5 as *const u8);
let v = Arc::new(Mutex::new(&b));
let t = thread::spawn(move || {
    let _v1 =  v.lock().unwrap();
});

t.join().unwrap();

感觉Mutex::new接收的参数类型都是&MyBox啊

[mumumusuc]

mutex使用了b的引用又不能保证b的生命周期比自己长，当然就报错啦

[peterhuang621]

粗浅的理解一下：
多线程章节的move那里有说，主线程可能提前结束把b drop掉，这时进入t线程当然就出错，即b的引用不一定一直有效。但是文章里面b直接就是一个引用，主线程即使结束也无法drop掉，自然不存在问题。
fn main(){
let b = &MyBox(5 as *const u8);
let v = Arc::new(Mutex::new(b));
let t = thread::spawn(move || {
println!("{:?}", *v.lock().unwrap());
});
t.join().unwrap();
drop(b);// warning not error!
println!("{:?}", b);
}
warning: calls to std::mem::drop with a reference instead of an owned value does nothing

[lihongtao1024]

b是一个临时变量，v智能指针持有该变量的引用的话，&b的生命周期不够长啊。

…

------------------ 原始邮件 ------------------ 发件人: ***@***.***>; 发送时间: 2023年2月9日(星期四) 凌晨0:36 收件人: ***@***.***>; 抄送: ***@***.***>; ***@***.***>; 主题: Re: [sunface/rust-course] advance/concurrency-with-threads/send-sync (Discussion #763) 请教下，实现Sync智能指针的那部分代码为什么这样实现会在Mutex::new的地方报错 borrowed value does not live long enough let b = MyBox(5 as *const u8); let v = Arc::new(Mutex::new(&b)); let t = thread::spawn(move || { let _v1 = v.lock().unwrap(); }); t.join().unwrap(); 感觉Mutex::new接收的参数类型都是&MyBox啊 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[GIfted-Jarvis]

use std::thread;
use std::time::Duration;
fn main() {
    let new_thread = thread::spawn(move || {
        thread::spawn(move || loop {
            println!("I am a new thread.");
            thread::sleep(Duration::from_millis(1));
        });
        thread::spawn(move || loop {
            println!("I am b new thread.");
            thread::sleep(Duration::from_millis(1));
        });
        thread::spawn(move || loop {
            println!("I am c new thread.");
            thread::sleep(Duration::from_millis(1));
        });
        thread::spawn(move || loop {
            println!("I am d new thread.");
            thread::sleep(Duration::from_millis(1));
        });
    });
    new_thread.join().unwrap();
    thread::sleep(Duration::from_secs(100));
}

四核的机器(17款 MBP)这样写, cpu 使用率确实上来了, 但是每个核都没到 100%, 只有 50~60, 为什么?

[curtiseng]

因为sleep了

[MySilentCat]

复合类型中有一个成员没实现Send，该复合类型就不是Send，因此我们需要手动为它实现:

#[derive(Debug)]
struct MyBox(*mut u8);
unsafe impl Send for MyBox {}

这里MyBox(mut u8)是复合类型吗？请问如何理解mut u8没有实现Send，而为MyBox 实现Send就足够了？

[MySilentCat]

是直接越过*mut u8了，为其包裹住的实现Send就行了，是否这样理解

[MqCreaple]

*mut u8没有实现Send是有其原因的，因为Rust不希望使用者能够随便把指针在线程间传递。具体可以参考Rust官方文档：https://doc.rust-lang.org/nomicon/send-and-sync.html。

下一行的unsafe impl Send for MyBox {}就相当于手动告诉编译器不管这个类型里面的东西能不能Send，这个类型本身都可以安全地在进程间共享。由于这个声明不符合safe rust的规范，所以需要加unsafe关键字。

[yurnery]

由上可知，若类型 T 的引用&T是Send，则T是Sync。

这里是不是写反了，应该是 如果 T 是 Sync 的，那么&T 就一定 Send的

[MqCreaple]

求教一下，我现在想实现这样一个功能：生成n个线程，并且将一个数组里的n个元素分别传入n个线程，该怎么用代码实现？伪代码大致如下：

use std::thread;

struct T {
    a: i32,
    b: String,
    // some other fields that implements Send and Sync
}

const N: usize = 5;

fn main() {
    thread::scope(move |s| {
        let array: [Box<T>; N];
        // some code that initialize `array` at run time
        for i in 0..N {
            thread::spawn(move || {
                // take ownership of i
                let a = array[i];
                // Some operations to `a`
            });
        };
    });
}

N是编译时确定的，但数组本身的内容是运行时确定的。用Arc<Mutex<T>>来在线程间共享T可能会有性能问题，最好还是能让子线程直接获得数组里每个元素的ownership。这种有办法做吗？

[1057105012]

like this

use std::thread;

static ARR_SIZE: usize = 5;

fn main() {
let arr = vec![1, 2, 3];
thread::scope(move |s| {
for i in 0..ARR_SIZE {
let arr_item = arr[i];
thread::spawn(move || {
println!("{}", arr_item);
});
};
});
}

[MqCreaple]

这个例子里用的是Vec<i32>，整数类型本身是能复制的（即实现了Copy特征），所以不用考虑变量所有权的问题。我希望能获得一个对于更一般的类型（比如String等没有Copy特征的类型）也适用的解决方法。

上述代码里如果直接把vec![1, 2, 3]换成一个String数组就会出问题：

use std::thread;

static ARR_SIZE: usize = 5;

fn main() {
    let arr = vec![
        String::from("Hello"),
        String::from("World"),
        String::from("Alice"),
    ];
    thread::scope(move |s| {
        for i in 0..ARR_SIZE {
            let arr_item = arr[i];
            thread::spawn(move || {
                println!("{}", arr_item);
            });
        };
    });
}

[trend-ouki-wang]

Arc把arr包起来，然后共享

use std::sync::Arc;
use std::thread;

static ARR_SIZE: usize = 3;

fn main() {
let arr = vec![
String::from("Hello"),
String::from("World"),
String::from("Alice"),
];
let arr_arc = Arc::new(arr);
thread::scope(move |s| {
for i in 0..ARR_SIZE {
let arr_ = Arc::clone(&arr_arc);
s.spawn(move || {
println!("{}", arr_[i]);
});
}
});
}