Struct std::sync::atomic::AtomicBool1.0.0[−][src]

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

Expand description

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

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

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

Implementations

impl AtomicBool

[src]

pub const fn new(v: bool) -> AtomicBool

1.0.0 (const: 1.24.0)[src]

创建一个新的 AtomicBool。

Examples

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

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

Run

pub fn get_mut(&mut self) -> &mut bool

1.15.0 [src]

返回基础 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

pub fn from_mut(v: &mut bool) -> &AtomicBool

[src]

🔬 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

pub const fn into_inner(self) -> bool

1.15.0 [src]

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

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

Examples

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

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

Run

pub fn load(&self, order: Ordering) -> bool

[src]

从 bool 加载一个值。

load 采用 Ordering 参数，该参数描述此操作的内存顺序。可能的值为 SeqCst，Acquire 和 Relaxed。

Panics

如果 order 是 Release 或 AcqRel，则为 Panics。

Examples

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

let some_bool = AtomicBool::new(true);

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

Run

pub fn store(&self, val: bool, order: Ordering)

[src]

将值存储到 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);

Run

pub fn swap(&self, val: bool, order: Ordering) -> bool

[src]

将值存储到 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

pub fn compare_and_swap(
    &self,
    current: bool,
    new: bool,
    order: Ordering
) -> bool

[src]

👎 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_exchange` 和 `compare_exchange_weak`

compare_and_swap 与 compare_exchange 等效，具有以下有关内存顺序的映射:

Original	Success	Failure
Relaxed	Relaxed	Relaxed 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

pub fn compare_exchange(
 &self,
 current: bool,
 new: bool,
 success: Ordering,
 failure: Ordering
) -> Result<bool, bool>

1.10.0 [src]

如果当前值与 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);

Run

pub fn compare_exchange_weak(
 &self,
 current: bool,
 new: bool,
 success: Ordering,
 failure: Ordering
) -> Result<bool, bool>

1.10.0 [src]

如果当前值与 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,
    }
}

Run

pub fn fetch_and(&self, val: bool, order: Ordering) -> bool

[src]

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

pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool

[src]

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

pub fn fetch_or(&self, val: bool, order: Ordering) -> bool

[src]

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

pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool

[src]

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

pub fn as_mut_ptr(&self) -> *mut bool

[src]

🔬 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

pub fn fetch_update<F>(
 &self,
 set_order: Ordering,
 fetch_order: Ordering,
 f: F
) -> Result<bool, bool> where
 F: FnMut(bool) -> Option<bool>,

1.53.0 [src]

获取该值，并对其应用一个函数，该函数返回一个可选的新值。如果函数返回 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);

Run

Trait Implementations

impl Debug for AtomicBool

1.3.0[src]

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

[src]

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

impl Default for AtomicBool

[src]

pub fn default() -> AtomicBool

[src]

创建一个初始化为 false 的 AtomicBool。

impl From<bool> for AtomicBool

1.24.0[src]

pub fn from(b: bool) -> AtomicBool

[src]

将 bool 转换为 AtomicBool。

Examples

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

Run

impl RefUnwindSafe for AtomicBool

1.14.0[src]

impl Sync for AtomicBool

[src]

Auto Trait Implementations

impl Send for AtomicBool

impl Unpin for AtomicBool

impl UnwindSafe for AtomicBool

Blanket Implementations

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

[src]

获取 self 的 TypeId。 Read more

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

[src]

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

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

[src]

从拥有的值中借用。 Read more

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

[src]

执行转换。

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

[src]

执行转换。

impl<T, U> TryFrom for T where
U: Into<T>,

[src]

type Error = Infallible

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

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

[src]

执行转换。

impl<T, U> TryInto for T where
U: TryFrom<T>,

[src]

type Error = >::Error

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

pub fn try_into(self) -> Result<U, >::Error>

[src]

执行转换。

Struct std::sync::atomic::AtomicBool1.0.0[−][src]

Implementations

impl AtomicBool

pub const fn new(v: bool) -> AtomicBool

pub fn get_mut(&mut self) -> &mut bool

pub fn from_mut(v: &mut bool) -> &AtomicBool

pub const fn into_inner(self) -> bool

pub fn load(&self, order: Ordering) -> bool

pub fn store(&self, val: bool, order: Ordering)

pub fn swap(&self, val: bool, order: Ordering) -> bool

pub fn compare_and_swap( &self, current: bool, new: bool, order: Ordering) -> bool

pub fn compare_exchange( &self, current: bool, new: bool, success: Ordering, failure: Ordering) -> Result<bool, bool>

pub fn compare_exchange_weak( &self, current: bool, new: bool, success: Ordering, failure: Ordering) -> Result<bool, bool>

pub fn fetch_and(&self, val: bool, order: Ordering) -> bool

pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool

pub fn fetch_or(&self, val: bool, order: Ordering) -> bool

pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool

pub fn as_mut_ptr(&self) -> *mut bool

pub fn fetch_update<F>( &self, set_order: Ordering, fetch_order: Ordering, f: F) -> Result<bool, bool> where F: FnMut(bool) -> Option<bool>,

Trait Implementations

impl Debug for AtomicBool

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Default for AtomicBool

pub fn default() -> AtomicBool

impl From<bool> for AtomicBool

pub fn from(b: bool) -> AtomicBool

impl RefUnwindSafe for AtomicBool

impl Sync for AtomicBool

Auto Trait Implementations

impl Send for AtomicBool

impl Unpin for AtomicBool

impl UnwindSafe for AtomicBool

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

pub fn compare_and_swap(
&self,
current: bool,
new: bool,
order: Ordering
) -> bool

pub fn compare_exchange(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>

pub fn compare_exchange_weak(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>

pub fn fetch_update<F>(
&self,
set_order: Ordering,
fetch_order: Ordering,
f: F
) -> Result<bool, bool> where
F: FnMut(bool) -> Option<bool>,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,