Struct std::sync::atomic::AtomicBool 1.0.0[−][src]
#[repr(C, align(1))]pub struct AtomicBool { /* fields omitted */ }Expand description
Implementations
将值存储到 bool 中。
store 需要一个 Ordering 参数，它描述了这个操作的内存顺序。
可能的值为 SeqCst，Release 和 Relaxed。
Panics
如果 order 是 Acquire 或 AcqRel，就会出现 panics。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let some_bool = AtomicBool::new(true);
some_bool.store(false, Ordering::Relaxed);
assert_eq!(some_bool.load(Ordering::Relaxed), false);将值存储到 bool 中，返回前一个值。
swap 需要一个 Ordering 参数，它描述了这个操作的内存顺序。所有排序模式都是可能的。
请注意，使用 Acquire 会使该操作成为存储部分 Relaxed，而使用 Release 会使装入部分成为 Relaxed。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let some_bool = AtomicBool::new(true);
assert_eq!(some_bool.swap(false, Ordering::Relaxed), true);
assert_eq!(some_bool.load(Ordering::Relaxed), false);👎 Deprecated since 1.50.0: Use compare_exchange or compare_exchange_weak instead
Use compare_exchange or compare_exchange_weak instead
如果当前值与 current 值相同，则将值存储到 bool 中。
返回值始终是前一个值。如果等于 current，则该值已更新。
compare_and_swap 还带有一个 Ordering 参数，它描述了此操作的内存顺序。
请注意，即使使用 AcqRel，该操作也可能失败，因此仅执行 Acquire 加载，但没有 Release 语义。
如果发生此操作，则使用 Acquire 使其成为该操作 Relaxed 的存储部分，而使用 Release 使该操作成为存储部分 Relaxed。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
迁移到 compare_exchange 和 compare_exchange_weak
compare_and_swap 等效于 compare_exchange，具有以下内存排序映射：
| Original | Success | Failure |
|---|---|---|
| Relaxed | Relaxed | Relaxed Acquire |
即使比较成功，compare_exchange_weak 也允许虚假失败，这允许编译器在循环中使用比较和交换时生成更好的汇编代码。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let some_bool = AtomicBool::new(true);
assert_eq!(some_bool.compare_and_swap(true, false, Ordering::Relaxed), true);
assert_eq!(some_bool.load(Ordering::Relaxed), false);
assert_eq!(some_bool.compare_and_swap(true, true, Ordering::Relaxed), false);
assert_eq!(some_bool.load(Ordering::Relaxed), false);如果当前值与 current 值相同，则将值存储到 bool 中。
返回值是指示是否写入了新值并包含先前值的结果。
成功后，此值保证等于 current。
compare_exchange 需要两个 Ordering 参数来描述这个操作的内存顺序。
success 描述了在与 current 的比较成功时发生的读取 - 修改 - 写入操作所需的顺序。
failure 描述了比较失败时发生的加载操作所需的排序。
使用 Acquire 作为成功排序，使存储成为操作 Relaxed 的一部分，而使用 Release，则使装载成功 Relaxed。
失败排序只能是 SeqCst，Acquire 或 Relaxed，并且必须等于或弱于成功排序。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let some_bool = AtomicBool::new(true);
assert_eq!(some_bool.compare_exchange(true,
false,
Ordering::Acquire,
Ordering::Relaxed),
Ok(true));
assert_eq!(some_bool.load(Ordering::Relaxed), false);
assert_eq!(some_bool.compare_exchange(true, true,
Ordering::SeqCst,
Ordering::Acquire),
Err(false));
assert_eq!(some_bool.load(Ordering::Relaxed), false);如果当前值与 current 值相同，则将值存储到 bool 中。
与 AtomicBool::compare_exchange 不同，即使比较成功，也允许该函数错误地失败，这可能导致某些平台上的代码效率更高。
返回值是指示是否写入了新值并包含先前值的结果。
compare_exchange_weak 需要两个 Ordering 参数来描述这个操作的内存顺序。
success 描述了在与 current 的比较成功时发生的读取 - 修改 - 写入操作所需的顺序。
failure 描述了比较失败时发生的加载操作所需的排序。
使用 Acquire 作为成功排序，使存储成为操作 Relaxed 的一部分，而使用 Release，则使装载成功 Relaxed。
失败排序只能是 SeqCst，Acquire 或 Relaxed，并且必须等于或弱于成功排序。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let val = AtomicBool::new(false);
let new = true;
let mut old = val.load(Ordering::Relaxed);
loop {
match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {
Ok(_) => break,
Err(x) => old = x,
}
}具有布尔值的逻辑 “and”。
对当前值和参数 val 执行逻辑 “and” 运算，并将新值设置为结果。
返回前一个值。
fetch_and 需要一个 Ordering 参数，它描述了这个操作的内存顺序。所有排序模式都是可能的。
请注意，使用 Acquire 会使该操作成为存储部分 Relaxed，而使用 Release 会使装入部分成为 Relaxed。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_and(false, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), false);
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_and(true, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);
let foo = AtomicBool::new(false);
assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false);
assert_eq!(foo.load(Ordering::SeqCst), false);具有布尔值的逻辑 “nand”。
对当前值和参数 val 执行逻辑 “nand” 运算，并将新值设置为结果。
返回前一个值。
fetch_nand 需要一个 Ordering 参数，它描述了这个操作的内存顺序。所有排序模式都是可能的。
请注意，使用 Acquire 会使该操作成为存储部分 Relaxed，而使用 Release 会使装入部分成为 Relaxed。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst) as usize, 0);
assert_eq!(foo.load(Ordering::SeqCst), false);
let foo = AtomicBool::new(false);
assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);
assert_eq!(foo.load(Ordering::SeqCst), true);具有布尔值的逻辑 “or”。
对当前值和参数 val 执行逻辑 “or” 运算，并将新值设置为结果。
返回前一个值。
fetch_or 需要一个 Ordering 参数，它描述了这个操作的内存顺序。所有排序模式都是可能的。
请注意，使用 Acquire 会使该操作成为存储部分 Relaxed，而使用 Release 会使装入部分成为 Relaxed。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);
let foo = AtomicBool::new(false);
assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false);
assert_eq!(foo.load(Ordering::SeqCst), false);具有布尔值的逻辑 “xor”。
对当前值和参数 val 执行逻辑 “xor” 运算，并将新值设置为结果。
返回前一个值。
fetch_xor 需要一个 Ordering 参数，它描述了这个操作的内存顺序。所有排序模式都是可能的。
请注意，使用 Acquire 会使该操作成为存储部分 Relaxed，而使用 Release 会使装入部分成为 Relaxed。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);
let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), false);
let foo = AtomicBool::new(false);
assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);
assert_eq!(foo.load(Ordering::SeqCst), false);返回指向底层 bool 的可变指针。
在结果整数上进行非原子读取和写入可以是数据竞争。
此方法对 FFI 最为有用，在 FFI 中，函数签名可以使用 *mut bool 而不是 &AtomicBool。
从共享引用返回 *mut 指针到此原子是安全的，因为原子类型可与内部可变性一起使用。
原子的所有修改都通过共享的 quot 更改值，并且只要它们使用原子操作就可以安全地进行更改。
对返回的裸指针的任何使用都需要一个 unsafe 块，并且仍然必须遵守相同的限制：对其进行的操作必须是原子的。
Examples
use std::sync::atomic::AtomicBool;
extern "C" {
fn my_atomic_op(arg: *mut bool);
}
let mut atomic = AtomicBool::new(true);
unsafe {
my_atomic_op(atomic.as_mut_ptr());
}获取该值，并对其应用一个函数，该函数返回一个可选的新值。如果函数返回 Some(_)，则返回 Ok(previous_value) 的 Result，否则返回 Err(previous_value)。
Note: 如果与此同时从其他线程更改了值，则只要函数返回 Some(_)，这可能会多次调用该函数，但是该函数仅对存储的值应用一次。
fetch_update 需要两个 Ordering 参数来描述这个操作的内存顺序。
第一个描述了操作最终成功时所需的顺序，第二个描述了负载所需的顺序。
这些分别对应于 AtomicBool::compare_exchange 的成功和失败顺序。
使用 Acquire 作为成功排序，使存储成为该操作 Relaxed 的一部分，而使用 Release，则使最终成功加载 Relaxed。
(failed) 负载排序只能是 SeqCst，Acquire 或 Relaxed，并且必须等于或小于成功排序。
Note: 此方法仅在支持 u8 上原子操作的平台上可用。
Examples
use std::sync::atomic::{AtomicBool, Ordering};
let x = AtomicBool::new(false);
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(false));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(false));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(true));
assert_eq!(x.load(Ordering::SeqCst), false);Trait Implementations
创建一个初始化为 false 的 AtomicBool。