Namespaces
Variants

std:: atomic <std::weak_ptr>

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::weak_ptr
헤더에 정의됨 <memory>
template < class T > struct std:: atomic < std:: weak_ptr < T >> ;
(C++20부터)

std::atomic 의 부분 템플릿 특수화가 std:: weak_ptr < T > 에 대해 제공되며, 이를 통해 사용자는 weak_ptr 객체를 원자적으로 조작할 수 있습니다.

다수의 실행 스레드가 동기화 없이 동일한 std::weak_ptr 객체에 접근하고, 그 중 어떤 접근이 weak_ptr 의 비-const 멤버 함수를 사용하는 경우, std:: atomic < std:: weak_ptr > 인스턴스를 통하지 않은 모든 접근에 대해 데이터 경쟁이 발생합니다.

연관된 use_count 증가는 원자적 연산의 일부로 보장됩니다. 연관된 use_count 감소는 원자적 연산 이후에 순서가 지정되지만, CAS 실패 시 expected 를 재정의할 때의 use_count 변경을 제외하고는 원자적 연산의 일부일 필요는 없습니다. 연관된 모든 삭제 및 할당 해제는 원자적 업데이트 단계 이후에 순서가 지정되며 원자적 연산의 일부가 아닙니다.

std::weak_ptr 와 std::shared_ptr 가 사용하는 제어 블록은 스레드 안전합니다: 서로 다른 비-원자적 std::weak_ptr 객체들은 operator = 또는 reset 과 같은 가변 연산을 사용하여 여러 스레드에서 동시에 접근할 수 있으며, 이러한 인스턴스들이 내부적으로 동일한 제어 블록을 공유하거나 복사본인 경우에도 마찬가지입니다.

타입 T 는 불완전한 타입일 수 있습니다.

목차

멤버 타입

멤버 타입 정의
value_type std:: weak_ptr < T >

멤버 함수

모든 비전문화 std::atomic 함수들은 이 특수화에 의해 제공되며, 추가적인 멤버 함수는 존재하지 않습니다.

atomic<weak_ptr<T>>:: atomic

constexpr atomic ( ) noexcept = default ;
(1)
atomic ( std:: weak_ptr < T > desired ) noexcept ;
(2)
atomic ( const atomic & ) = delete ;
(3)
1) 기본 생성된 값으로 내부 weak_ptr<T> 를 초기화합니다.
2) 내부 weak_ptr<T> 를 desired 의 복사본으로 초기화합니다. 다른 std::atomic 타입과 마찬가지로, 초기화는 원자적 연산이 아닙니다.
3) 원자적 타입은 복사/이동 생성이 불가능합니다.

atomic<weak_ptr<T>>:: operator=

void operator = ( const atomic & ) = delete ;
(1)
void operator = ( std:: weak_ptr < T > desired ) noexcept ;
(2)
1) 원자적 타입은 복사/이동 할당이 불가능합니다.
2) 값 할당으로, store ( desired ) 과 동일합니다.

atomic<weak_ptr<T>>:: is_lock_free

bool is_lock_free ( ) const noexcept ;

이 타입의 모든 객체에 대한 원자적 연산이 잠금 없는(lock-free) 경우 true를 반환하고, 그렇지 않으면 false를 반환합니다.

atomic<weak_ptr<T>>:: store

void store ( std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;

* this 의 값을 desired 값으로 원자적으로 교체합니다. 이는 내부 p 가 std:: weak_ptr < T > 인 경우 p. swap ( desired ) 을 호출하는 것과 같습니다. 메모리 순서는 order 에 따라 정해집니다. order 가 std::memory_order_consume , std::memory_order_acquire , 또는 std::memory_order_acq_rel 인 경우 동작은 정의되지 않습니다.

atomic<weak_ptr<T>>:: load

기본에 있는 std:: weak_ptr < T > 의 복사본을 원자적으로 반환합니다. 메모리는 order 에 따라 정렬됩니다. order 가 std::memory_order_release 또는 std::memory_order_acq_rel 인 경우 동작은 정의되지 않습니다.

atomic<weak_ptr<T>>:: operator std::weak_ptr<T>

operator std:: weak_ptr < T > ( ) const noexcept ;

return load ( ) ; 와 동등합니다.

atomic<weak_ptr<T>>:: exchange

기본 std:: weak_ptr < T > 을 desired 로 원자적으로 교체하며, p. swap ( desired ) 를 수행한 것처럼 동작합니다. 여기서 p 는 기본 std:: weak_ptr < T > 이며, 교체 직전 p 가 가지고 있던 값의 복사본을 반환합니다. 메모리는 order 에 따라 정렬됩니다. 이는 원자적 읽기-수정-쓰기 연산입니다.

atomic<weak_ptr<T>>:: compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(1)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(2)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(3)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(4)
1) 기본 std:: weak_ptr < T > 이 expected 와 동일한 포인터 값을 저장하고 소유권을 공유하거나, 기본과 expected 가 모두 비어 있는 경우, desired 를 기본 std:: weak_ptr < T > 에 할당하고, true 를 반환하며, success 에 따라 메모리 순서를 지정합니다. 그렇지 않으면 기본 std:: weak_ptr < T > 을 expected 에 할당하고, false 를 반환하며, failure 에 따라 메모리 순서를 지정합니다. failure 가 std::memory_order_release 또는 std::memory_order_acq_rel 인 경우 동작은 정의되지 않습니다. 성공 시 이 연산은 * this 에 대한 원자적 읽기-수정-쓰기 연산이며, expected 는 원자적 갱신 이후 접근되지 않습니다. 실패 시 이 연산은 * this 에 대한 원자적 읽기 연산이며, expected 는 원자적 객체에서 읽은 기존 값으로 갱신됩니다. expected 의 use_count에 대한 이 갱신은 이 원자적 연산의 일부이지만, 쓰기 자체(및 이후의 할당 해제/소멸)는 반드시 그럴 필요는 없습니다.
2) (1) 과 동일하지만, 가끔 잘못된 실패를 보일 수도 있습니다.
3) 다음과 동등함: return compare_exchange_strong ( expected, desired, order, fail_order ) ; , 여기서 fail_order 는 order 와 동일하지만, std::memory_order_acq_rel 은 std::memory_order_acquire 로 대체되고, std::memory_order_release 은 std::memory_order_relaxed 로 대체됨.
4) 다음과 동등함: return compare_exchange_weak ( expected, desired, order, fail_order ) ; , 단 fail_order 는 order 와 동일하지만 다음 조건이 적용됨: std::memory_order_acq_rel 은 std::memory_order_acquire 로 대체되고, std::memory_order_release 은 std::memory_order_relaxed 로 대체됨.

atomic<weak_ptr<T>>:: wait

void wait ( std:: weak_ptr < T > old
std:: memory_order order = std:: memory_order_seq_cst ) const noexcept ;

원자적 대기 연산을 수행합니다.

load ( order ) 을 old 와 비교하여 동등한 경우 notify_one() 또는 notify_all() 에 의해 * this 가 통지될 때까지 블록합니다. 이는 load ( order ) 이 변경될 때까지 반복됩니다. 이 함수는 기본 구현이 spuriously 언블록되는 경우에도 값이 변경된 경우에만 반환되는 것이 보장됩니다.

메모리는 order 에 따라 정렬됩니다. order 가 std::memory_order_release 또는 std::memory_order_acq_rel 인 경우 동작은 정의되지 않습니다.

참고: 두 개의 std::weak_ptr 은 동일한 포인터를 저장하고 소유권을 공유하거나 둘 다 비어 있는 경우 동등합니다.

atomic<weak_ptr<T>>:: notify_one

void notify_one ( ) noexcept ;

원자적 통지 연산을 수행합니다.

만약 * this 에서 원자적 대기 연산(즉, wait() ) 중에 차단된 스레드가 있다면, 그러한 스레드 중 최소한 하나를 차단 해제합니다; 그렇지 않으면 아무 작업도 수행하지 않습니다.

atomic<weak_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

원자적 통지 작업을 수행합니다.

* this 에서 원자적 대기 작업(즉, wait() ) 중에 차단된 모든 스레드의 차단을 해제합니다. 차단된 스레드가 없는 경우 아무 작업도 수행하지 않습니다.

멤버 상수

유일한 표준 std::atomic 멤버 상수 is_always_lock_free 도 이 특수화에 의해 제공됩니다.

atomic<weak_ptr<T>>:: is_always_lock_free

static constexpr bool is_always_lock_free = /*implementation-defined*/ ;

예제

이 섹션은 불완전합니다
이유: 예제 없음

참고 항목

(C++11)
bool, 정수형, 부동소수점, (since C++20) 및 포인터 타입에 대한 atomic 클래스 템플릿과 특수화
(클래스 템플릿)