Struct core::sync::atomic::AtomicBool1.0.0[][src]

#[repr(C, align(1))]
pub struct AtomicBool { /* fields omitted */ }
Expand description

可以在线程之间安全共享的布尔类型。

此类型与 bool 具有相同的内存表示形式。

Note: 此类型仅在支持 u8 的原子加载和存储的平台上可用。

Implementations

创建一个新的 AtomicBool

Examples

use std::sync::atomic::AtomicBool;

let atomic_true  = AtomicBool::new(true);
let atomic_false = AtomicBool::new(false);
Run

返回基础 bool 的可变引用。

这是安全的,因为可变引用保证没有其他线程同时访问原子数据。

Examples

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

let mut some_bool = AtomicBool::new(true);
assert_eq!(*some_bool.get_mut(), true);
*some_bool.get_mut() = false;
assert_eq!(some_bool.load(Ordering::SeqCst), false);
Run
🔬 This is a nightly-only experimental API. (atomic_from_mut #76314)

获得对 &mut bool 的原子访问。

Examples

#![feature(atomic_from_mut)]
use std::sync::atomic::{AtomicBool, Ordering};

let mut some_bool = true;
let a = AtomicBool::from_mut(&mut some_bool);
a.store(false, Ordering::Relaxed);
assert_eq!(some_bool, false);
Run

消耗原子并返回包含的值。

这是安全的,因为按值传递 self 可以确保没有其他线程同时访问原子数据。

Examples

use std::sync::atomic::AtomicBool;

let some_bool = AtomicBool::new(true);
assert_eq!(some_bool.into_inner(), true);
Run

从 bool 加载一个值。

load 采用 Ordering 参数,该参数描述此操作的内存顺序。 可能的值为 SeqCstAcquireRelaxed

Panics

如果 orderReleaseAcqRel,则为 Panics。

Examples

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

let some_bool = AtomicBool::new(true);

assert_eq!(some_bool.load(Ordering::Relaxed), true);
Run

将值存储到 bool 中。

store 采用 Ordering 参数,该参数描述此操作的内存顺序。 可能的值为 SeqCstReleaseRelaxed

Panics

如果 orderAcquireAcqRel,则为 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);
Run

将值存储到 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);
Run
👎 Deprecated since 1.50.0:

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_exchangecompare_exchange_weak

compare_and_swapcompare_exchange 等效,具有以下有关内存顺序的映射:

OriginalSuccessFailure
RelaxedRelaxedRelaxed Acquire

compare_exchange_weak 即使比较成功,也允许错误地失败,这允许在循环中使用 compare 和 swap 时编译器生成更好的汇编代码。

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);
Run

如果当前值与 current 值相同,则将值存储到 bool 中。

返回值是指示是否写入了新值并包含先前值的结果。 成功后,此值保证等于 current

compare_exchange 需要两个 Ordering 参数来描述此操作的内存顺序。 success 描述了如果与 current 的比较成功,则进行读 - 修改 - 写操作所需的顺序。 failure 描述比较失败时发生的加载操作所需的顺序。 使用 Acquire 作为成功排序,使存储成为操作 Relaxed 的一部分,而使用 Release,则使装载成功 Relaxed

失败排序只能是 SeqCstAcquireRelaxed,并且必须等于或弱于成功排序。

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);
Run

如果当前值与 current 值相同,则将值存储到 bool 中。

AtomicBool::compare_exchange 不同,即使比较成功,也允许该函数错误地失败,这可能导致某些平台上的代码效率更高。

返回值是指示是否写入了新值并包含先前值的结果。

compare_exchange_weak 需要两个 Ordering 参数来描述此操作的内存顺序。 success 描述了如果与 current 的比较成功,则进行读 - 修改 - 写操作所需的顺序。 failure 描述比较失败时发生的加载操作所需的顺序。 使用 Acquire 作为成功排序,使存储成为操作 Relaxed 的一部分,而使用 Release,则使装载成功 Relaxed。 失败排序只能是 SeqCstAcquireRelaxed,并且必须等于或弱于成功排序。

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,
    }
}
Run

具有布尔值的逻辑 “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);
Run

具有布尔值的逻辑 “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);
Run

具有布尔值的逻辑 “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);
Run

具有布尔值的逻辑 “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);
Run
🔬 This is a nightly-only experimental API. (atomic_mut_ptr #66893)

recently added

返回指向基础 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());
}
Run

获取该值,并对其应用一个函数,该函数返回一个可选的新值。如果函数返回 Some(_),则返回 Ok(previous_value)Result,否则返回 Err(previous_value)

Note: 如果与此同时从其他线程更改了值,则只要函数返回 Some(_),这可能会多次调用该函数,但是该函数仅对存储的值应用一次。

fetch_update 需要两个 Ordering 参数来描述此操作的内存顺序。 第一个描述了操作最终成功时所需的顺序,第二个描述了负载所需的顺序。 这些分别对应于 AtomicBool::compare_exchange 的成功和失败顺序。

使用 Acquire 作为成功排序,使存储成为该操作 Relaxed 的一部分,而使用 Release,则使最终成功加载 Relaxed。 (failed) 负载排序只能是 SeqCstAcquireRelaxed,并且必须等于或小于成功排序。

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);
Run

Trait Implementations

使用给定的格式化程序格式化该值。 Read more

创建一个初始化为 falseAtomicBool

bool 转换为 AtomicBool

Examples

use std::sync::atomic::AtomicBool;
let atomic_bool = AtomicBool::from(true);
assert_eq!(format!("{:?}", atomic_bool), "true")
Run

Auto Trait Implementations

Blanket Implementations

获取 selfTypeIdRead more

从拥有的值中一成不变地借用。 Read more

从拥有的值中借用。 Read more

执行转换。

执行转换。

发生转换错误时返回的类型。

执行转换。

发生转换错误时返回的类型。

执行转换。