Rust AtomicPtr:：compare_exchange在指向结构的指针上使用时的行为是什么？

使用

compare\u exchange

是否会产生定义的行为

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

struct Dummy {
    foo: i64,
    bar: i64,
}

fn main() {
    let ptr = &mut Dummy { foo: 1, bar: 2 };
    let some_ptr = AtomicPtr::new(ptr);

    let other_ptr = &mut Dummy { foo: 10, bar: 10 };

    let value = some_ptr.compare_exchange(ptr, other_ptr, Ordering::SeqCst, Ordering::Relaxed);
}

如果定义了，定义的行为是什么？Rust是否会在受支持的体系结构（如x86_64）上使用双宽度CA执行上述操作

使用

compare\u exchange

是否会产生定义的行为

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

struct Dummy {
    foo: i64,
    bar: i64,
}

fn main() {
    let ptr = &mut Dummy { foo: 1, bar: 2 };
    let some_ptr = AtomicPtr::new(ptr);

    let other_ptr = &mut Dummy { foo: 10, bar: 10 };

    let value = some_ptr.compare_exchange(ptr, other_ptr, Ordering::SeqCst, Ordering::Relaxed);
}

在编译器或标准库中禁止bug时，安全锈不会导致C和C++意义上的未定义行为。此外，创建和操作指针总是安全的，只需取消对它们的引用或将它们转换为需要显式

不安全的引用，因为程序员需要提供编译器无法验证的保证。当然，对安全函数的特定调用是否达到预期效果是另一回事

如果定义了，定义的行为是什么

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

struct Dummy {
    foo: i64,
    bar: i64,
}

fn main() {
    let ptr = &mut Dummy { foo: 1, bar: 2 };
    let some_ptr = AtomicPtr::new(ptr);

    let other_ptr = &mut Dummy { foo: 10, bar: 10 };

    let value = some_ptr.compare_exchange(ptr, other_ptr, Ordering::SeqCst, Ordering::Relaxed);
}

该行为由文档指定：将地址
some_ptr
指向与
ptr
指向的地址进行比较，如果它们匹配，
some_ptr
会自动更新，以指向
other_ptr
提供的地址。在任何一种情况下都返回上一个指针。由于您的代码从
ptr
初始化
some_ptr
，并且不会创建可以更改它的线程，因此将导致
some_ptr
指向
other_ptr
提供的地址，并返回
ptr

Rust是否会在受支持的体系结构（如x86_64）上使用双宽度CA执行上述操作

AtomicPtr:：compare_exchange（）
只比较和交换指针，指针的宽度与usize

一样宽（现代硬件上为64位），没有理由使用双宽度CAS

但我想我理解了这种混乱是如何产生的：

compare\u exchange

的文档谈到了指针的值。这个“值”不是指向数据的值，它只是底层的

*mut T

指针，它只表示一个内存地址。就像一个

AtomicBool

的值是

bool

，一个

AtomicPtr

值是一个指针

如果文档提到的是“地址指向”而不是“的值”，则会稍微精确一些，但这更详细。（较短的“的地址”也可能是不明确的，因为它可能被理解为指向指针本身所在的地址。）

使用

compare\u exchange

是否会产生定义的行为

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

struct Dummy {
    foo: i64,
    bar: i64,
}

fn main() {
    let ptr = &mut Dummy { foo: 1, bar: 2 };
    let some_ptr = AtomicPtr::new(ptr);

    let other_ptr = &mut Dummy { foo: 10, bar: 10 };

    let value = some_ptr.compare_exchange(ptr, other_ptr, Ordering::SeqCst, Ordering::Relaxed);
}

在编译器或标准库中禁止bug时，安全锈不会导致C和C++意义上的未定义行为。此外，创建和操作指针总是安全的，只需取消对它们的引用或将它们转换为需要显式

不安全的引用，因为程序员需要提供编译器无法验证的保证。当然，对安全函数的特定调用是否达到预期效果是另一回事

如果定义了，定义的行为是什么

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

struct Dummy {
    foo: i64,
    bar: i64,
}

fn main() {
    let ptr = &mut Dummy { foo: 1, bar: 2 };
    let some_ptr = AtomicPtr::new(ptr);

    let other_ptr = &mut Dummy { foo: 10, bar: 10 };

    let value = some_ptr.compare_exchange(ptr, other_ptr, Ordering::SeqCst, Ordering::Relaxed);
}

该行为由文档指定：将地址
some_ptr
指向与
ptr
指向的地址进行比较，如果它们匹配，
some_ptr
会自动更新，以指向
other_ptr
提供的地址。在任何一种情况下都返回上一个指针。由于您的代码从
ptr
初始化
some_ptr
，并且不会创建可以更改它的线程，因此将导致
some_ptr
指向
other_ptr
提供的地址，并返回
ptr

Rust是否会在受支持的体系结构（如x86_64）上使用双宽度CA执行上述操作

AtomicPtr:：compare_exchange（）
只比较和交换指针，指针的宽度与usize

一样宽（现代硬件上为64位），没有理由使用双宽度CAS

但我想我理解了这种混乱是如何产生的：

compare\u exchange

的文档谈到了指针的值。这个“值”不是指向数据的值，它只是底层的

*mut T

指针，它只表示一个内存地址。就像一个

AtomicBool

的值是

bool

，一个

AtomicPtr

值是一个指针

---

如果文档提到的是“地址指向”而不是“的值”，则会稍微精确一些，但这更详细。（较短的“的地址”将再次变得模棱两可，因为它可能被理解为指向指针本身所在的地址。）

AtomicPtr:：compare_exchange

仅比较和交换指针，指针是64位的，没有理由与CAS进行双精度交换。是的，我对compare_exchange的理解是错误的。感谢您清理它

AtomicPtr:：compare\u exchange

只比较和交换指针，它是64位的，没有理由与CAS进行双精度交换。是的，我对compare\u exchange的理解是错误的。谢谢你把它清理干净