<!--
{
  "availability" : [
    "iOS: 18.0.0 -",
    "iPadOS: 18.0.0 -",
    "macCatalyst: 18.0.0 -",
    "macOS: 15.0.0 -",
    "tvOS: 18.0.0 -",
    "visionOS: 2.0.0 -",
    "watchOS: 11.0.0 -"
  ],
  "documentType" : "symbol",
  "framework" : "Swift",
  "identifier" : "/documentation/Synchronization/AtomicUpdateOrdering",
  "metadataVersion" : "0.1.0",
  "role" : "Structure",
  "symbol" : {
    "kind" : "Structure",
    "modules" : [
      "Synchronization"
    ],
    "preciseIdentifier" : "s:15Synchronization20AtomicUpdateOrderingV"
  },
  "title" : "AtomicUpdateOrdering"
}
-->

# AtomicUpdateOrdering

Specifies the memory ordering semantics of an atomic read-modify-write
operation.

```
@frozen struct AtomicUpdateOrdering
```

## Topics

### Type Properties

[`static var acquiring: AtomicUpdateOrdering`](/documentation/Synchronization/AtomicUpdateOrdering/acquiring)

An acquiring update synchronizes with a releasing operation
whose value its reads. It ensures that the releasing and
acquiring threads agree that all subsequent variable accesses on
the acquiring thread happen after the atomic operation itself.

[`static var acquiringAndReleasing: AtomicUpdateOrdering`](/documentation/Synchronization/AtomicUpdateOrdering/acquiringAndReleasing)

An acquiring-and-releasing operation is a combination of
`.acquiring` and `.releasing` operation on the same variable.

[`static var relaxed: AtomicUpdateOrdering`](/documentation/Synchronization/AtomicUpdateOrdering/relaxed)

Guarantees the atomicity of the specific operation on which it is applied,
but imposes no ordering constraints on any other variable accesses.

[`static var releasing: AtomicUpdateOrdering`](/documentation/Synchronization/AtomicUpdateOrdering/releasing)

A releasing update synchronizes with acquiring operations that
read the value it stores. It ensures that the releasing and
acquiring threads agree that all preceding variable accesses on
the releasing thread happen before the atomic operation itself.

[`static var sequentiallyConsistent: AtomicUpdateOrdering`](/documentation/Synchronization/AtomicUpdateOrdering/sequentiallyConsistent)

A sequentially consistent update performs an
acquiring-and-releasing update and also guarantees that it and
all other sequentially consistent atomic operations (loads, stores,
updates) appear to be executed in a single, total sequential
ordering.

## Relationships

### Conforms To

[`Hashable`](/documentation/Swift/Hashable)

[`Escapable`](/documentation/Swift/Escapable)

[`Sendable`](/documentation/Swift/Sendable)

[`SendableMetatype`](/documentation/Swift/SendableMetatype)

[`Copyable`](/documentation/Swift/Copyable)

[`BitwiseCopyable`](/documentation/Swift/BitwiseCopyable)

[`Equatable`](/documentation/Swift/Equatable)

[`CustomStringConvertible`](/documentation/Swift/CustomStringConvertible)

---

Copyright &copy; 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)