Struct core::sync::atomic::AtomicU321.34.0[][src]

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

可以在线程之间安全共享的整数类型。

此类型与基本整数类型 [` 具有相同的内存表示形式

u32 `]. 有关原子类型和非原子类型之间的区别以及有关此类型的可移植性的更多信息,请参见 module-level documentation

Note: 此类型仅在支持原子负载和 [` 的存储的平台上可用

u32 `].

Implementations

创建一个新的原子整数。

Examples

use std::sync::atomic::AtomicU32;

let atomic_forty_two = AtomicU32::new(42);
Run

返回基础整数的可变引用。

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

Examples

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

let mut some_var = AtomicU32::new(10);
assert_eq!(*some_var.get_mut(), 10);
*some_var.get_mut() = 5;
assert_eq!(some_var.load(Ordering::SeqCst), 5);
Run
🔬 This is a nightly-only experimental API. (atomic_from_mut #76314)

Get atomic access to a &mut u32.

Note: This function is only available on targets where u32 has an alignment of 4 bytes.

Examples

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

let mut some_int = 123;
let a = AtomicU32::from_mut(&mut some_int);
a.store(100, Ordering::Relaxed);
assert_eq!(some_int, 100);
Run

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

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

Examples

use std::sync::atomic::AtomicU32;

let some_var = AtomicU32::new(5);
assert_eq!(some_var.into_inner(), 5);
Run

从原子整数加载值。

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

Panics

如果 orderReleaseAcqRel,则为 Panics。

Examples

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

let some_var = AtomicU32::new(5);

assert_eq!(some_var.load(Ordering::Relaxed), 5);
Run

将值存储到原子整数中。

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

Panics

如果 orderAcquireAcqRel,则为 Panics。

Examples

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

let some_var = AtomicU32::new(5);

some_var.store(10, Ordering::Relaxed);
assert_eq!(some_var.load(Ordering::Relaxed), 10);
Run

将值存储到原子整数中,返回前一个值。

swap 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let some_var = AtomicU32::new(5);

assert_eq!(some_var.swap(10, Ordering::Relaxed), 5);
Run
👎 Deprecated since 1.50.0:

Use compare_exchange or compare_exchange_weak instead

如果当前值与 current 值相同,则将值存储到原子整数中。

返回值始终是前一个值。如果等于 current,则该值已更新。

compare_and_swap 还采用了 Ordering 参数,该参数描述了此操作的内存顺序。 请注意,即使使用 AcqRel,该操作也可能失败,因此仅执行 Acquire 加载,但没有 Release 语义。

如果发生此操作,则使用 Acquire 使其成为该操作 Relaxed 的存储部分,而使用 Release 使该操作成为存储部分 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

迁移到 compare_exchangecompare_exchange_weak

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

OriginalSuccessFailure
RelaxedRelaxedRelaxed Acquire

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

Examples

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

let some_var = AtomicU32::new(5);

assert_eq!(some_var.compare_and_swap(5, 10, Ordering::Relaxed), 5);
assert_eq!(some_var.load(Ordering::Relaxed), 10);

assert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);
assert_eq!(some_var.load(Ordering::Relaxed), 10);
Run

如果当前值与 current 值相同,则将值存储到原子整数中。

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

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

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

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let some_var = AtomicU32::new(5);

assert_eq!(some_var.compare_exchange(5, 10,
                                     Ordering::Acquire,
                                     Ordering::Relaxed),
           Ok(5));
assert_eq!(some_var.load(Ordering::Relaxed), 10);

assert_eq!(some_var.compare_exchange(6, 12,
                                     Ordering::SeqCst,
                                     Ordering::Acquire),
           Err(10));
assert_eq!(some_var.load(Ordering::Relaxed), 10);
Run

如果当前值与 current 值相同,则将值存储到原子整数中。

Unlike AtomicU32::compare_exchange, 即使比较成功,此函数也可能会虚假地失败,这可能导致某些平台上的代码效率更高。 返回值是指示是否写入了新值并包含先前值的结果。

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

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

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let val = AtomicU32::new(4);

let mut old = val.load(Ordering::Relaxed);
loop {
    let new = old * 2;
    match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {
        Ok(_) => break,
        Err(x) => old = x,
    }
}
Run

加到当前值,返回前一个值。

此操作在溢出时回绕。

fetch_add 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(0);
assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);
assert_eq!(foo.load(Ordering::SeqCst), 10);
Run

从当前值减去,返回前一个值。

此操作在溢出时回绕。

fetch_sub 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(20);
assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);
assert_eq!(foo.load(Ordering::SeqCst), 10);
Run

“and” 按位与当前值。

对当前值和参数 val 执行按位 “and” 运算,并将新值设置为结果。

返回前一个值。

fetch_and 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(0b101101);
assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b100001);
Run

“nand” 按位与当前值。

对当前值和参数 val 执行按位 “nand” 运算,并将新值设置为结果。

返回前一个值。

fetch_nand 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(0x13);
assert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);
assert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));
Run

“or” 按位与当前值。

对当前值和参数 val 执行按位 “or” 运算,并将新值设置为结果。

返回前一个值。

fetch_or 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(0b101101);
assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b111111);
Run

“xor” 按位与当前值。

对当前值和参数 val 执行按位 “xor” 运算,并将新值设置为结果。

返回前一个值。

fetch_xor 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(0b101101);
assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b011110);
Run

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

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

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

AtomicU32::compare_exchange respectively.

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

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let x = AtomicU32::new(7);
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
assert_eq!(x.load(Ordering::SeqCst), 9);
Run

当前值的最大值。

查找当前值和参数 val 的最大值,并将新值设置为结果。

返回前一个值。

fetch_max 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(23);
assert_eq!(foo.fetch_max(42, Ordering::SeqCst), 23);
assert_eq!(foo.load(Ordering::SeqCst), 42);
Run

如果要一步获得最大值,可以使用以下方法:

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

let foo = AtomicU32::new(23);
let bar = 42;
let max_foo = foo.fetch_max(bar, Ordering::SeqCst).max(bar);
assert!(max_foo == 42);
Run

当前值的最小值。

查找当前值和参数 val 的最小值,并将新值设置为结果。

返回前一个值。

fetch_min 采用 Ordering 参数,该参数描述此操作的内存顺序。所有排序模式都是可能的。 请注意,使用 Acquire 会使该操作成为存储部分 Relaxed,而使用 Release 会使装入部分成为 Relaxed

Note: 此方法仅在支持原子操作的平台上可用

u32.

Examples

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

let foo = AtomicU32::new(23);
assert_eq!(foo.fetch_min(42, Ordering::Relaxed), 23);
assert_eq!(foo.load(Ordering::Relaxed), 23);
assert_eq!(foo.fetch_min(22, Ordering::Relaxed), 23);
assert_eq!(foo.load(Ordering::Relaxed), 22);
Run

如果要一步获得最小值,则可以使用以下方法:

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

let foo = AtomicU32::new(23);
let bar = 12;
let min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);
assert_eq!(min_foo, 12);
Run
🔬 This is a nightly-only experimental API. (atomic_mut_ptr #66893)

recently added

返回指向基础整数的可变指针。

在结果整数上进行非原子读取和写入可以是数据竞争。 此方法对于 FFI 最为有用,在 FFI 中可能使用函数签名 *mut u32 instead of &AtomicU32. 从共享引用返回 *mut 指针到此原子是安全的,因为原子类型可与内部可变性一起使用。 原子的所有修改都通过共享的 quot 更改值,并且只要它们使用原子操作就可以安全地进行更改。 对返回的裸指针的任何使用都需要一个 unsafe 块,并且仍然必须遵守相同的限制: 对其进行的操作必须是原子的。

Examples

use std::sync::atomic::AtomicU32;

extern "C" {
    fn my_atomic_op(arg: *mut u32);
}

let mut atomic = AtomicU32::new(1);

unsafe {
    my_atomic_op(atomic.as_mut_ptr());
}
Run

Trait Implementations

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

返回类型的 “default value”。 Read more

Converts an u32 into an AtomicU32.

Auto Trait Implementations

Blanket Implementations

获取 selfTypeIdRead more

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

从拥有的值中借用。 Read more

执行转换。

执行转换。

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

执行转换。

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

执行转换。