multithreading - 在原子上调用 `into_inner()` 是否考虑了所有宽松的写入？

Question

into_inner() 是否返回此示例程序中的所有松弛写入？如果是这样，哪个概念可以保证这一点？

extern crate crossbeam;

use std::sync::atomic::{AtomicUsize, Ordering};

fn main() {
    let thread_count = 10;
    let increments_per_thread = 100000;
    let i = AtomicUsize::new(0);

    crossbeam::scope(|scope| {
        for _ in 0..thread_count {
            scope.spawn(|| {
                for _ in 0..increments_per_thread {
                    i.fetch_add(1, Ordering::Relaxed);
                }
            });
        }
    });

    println!(
        "Result of {}*{} increments: {}",
        thread_count,
        increments_per_thread,
        i.into_inner()
    );
}

( https://play.rust-lang.org/?gist=96f49f8eb31a6788b970cf20ec94f800&version=stable )

我知道 crossbeam 保证所有线程都完成，并且由于所有权回到主线程，我也知道不会有未完成的借用，但在我看来，仍然可能有未完成的待处理写入，如果不在 CPU 上，则在缓存中。

哪个概念保证在into_inner()被调用时，所有写操作完成，所有缓存同步回主线程？是否有可能丢失写入？

Answer 1

Does into_inner() return all the relaxed writes in this example program? If so, which concept guarantees this?

保证它的不是into_inner，而是join。

into_inner 保证的是自最后的并发写入(join 线程，最后一个 Arc 已被删除并使用 try_unwrap 等解包)，或者原子从未首先发送到另一个线程。这两种情况都足以使读取数据无争用。

横梁documentation明确关于在范围末尾使用 join:

This [the thread being guaranteed to terminate] is ensured by having the parent thread join on the child thread before the scope exits.

关于丢失写入:

Which concept guarantees that all writes are finished and all caches are synced back to the main thread when into_inner() is called? Is it possible to lose writes?

如 various 中所述places在文档中，Rust 继承了原子的 C++ 内存模型。 In C++11后来，完成了一个线程synchronizes with join 相应的成功返回。这意味着当 join 完成时，被加入线程执行的所有操作必须对调用 join 的线程可见，因此不可能丢失写入场景。

就原子性而言，您可以将 join 视为对原子的获取读取，线程在完成执行之前对其执行释放存储。