어떻게`weak_ptr` 및`shared_ptr` 액세스가 원자 단위입니까?

Question

std::shared_ptr<int> int_ptr; 

int main() { 
    int_ptr = std::make_shared<int>(1); 
    std::thread th{[&]() { 
     std::weak_ptr int_ptr_weak = int_ptr; 
     auto int_ptr_local = int_ptr_weak.lock(); 
     if (int_ptr_local) { 
      cout << "Value in the shared_ptr is " << *int_ptr_local << endl; 
     } 
    }); 

    int_ptr.reset(nullptr); 
    th.join(); 
    return 0; 
} 

위 코드는 스레드 안전합니까? 나는이 대답 About thread-safety of weak_ptr을 읽었지만, 위의 코드가 쓰레드에 안전한지 확인하고 싶었다.

위의 코드가 실제로 스레드 안전 인 경우 std::weak_ptr 및 std::shared_ptr 인터페이스가 다음 작업을 원자 단위로 처리하는 방법을 이해할 수 없음 expired() ? shared_ptr<T>() : shared_ptr<T>(*this). 위와 같은 두 개의 논리적 인 코드 라인을 만드는 것은 일종의 뮤텍스 나 스핀 록을 사용하지 않고는 동기화할 수 없다는 것입니다.

원자 증분이 공유 포인터의 다른 인스턴스에서 작동하는 방식을 알고 있고 shared_ptr 자체가 스레드 안전하지 않다는 것을 이해합니다. 그러나 위의 스레드가 실제로 안전 할 경우 스레드 안전과 매우 비슷합니다. shared_ptr과는 다릅니다. 위의 조건 에서처럼 두 줄의 코드를 자물쇠없이 원자 단위로 만들 수있는 방법을 이해합니다.

Answer 1

이 질문은 두 부분이 있습니다

스레드 안전성 코드는하지 스레드 입니다

을, 그러나 이것은 lock()와는 아무 상관이 없습니다 :
레이스가 int_ptr.reset(); 및 std::weak_ptr int_ptr_weak = int_ptr; 사이에 존재합니다.하나의 스레드가 비 원자 변수 int_ptr을 수정하는 동안 다른 스레드는이를 읽습니다. 이는 정의에 따라 데이터 경쟁입니다.

그래서이 확인 될 것이다 : 전체 과정이 원자 수 없습니다 물론 예제 코드 expired() ? shared_ptr<T>() : shared_ptr<T>(*this)

의

int main() { 
    auto int_ptr = std::make_shared<int>(1); 
    std::weak_ptr<int> int_ptr_weak = int_ptr; //create the weak pointer in the original thread 
    std::thread th([&]() { 
     auto int_ptr_local = int_ptr_weak.lock(); 
     if (int_ptr_local) { 
      std::cout << "Value in the shared_ptr is " << *int_ptr_local << std::endl; 
     } 
    }); 

    int_ptr.reset(); 
    th.join(); 
} 

원자 버전. 실제로 중요한 부분은 이미 심한 ref 카운트가 이미 0보다 크고 체크와 증가가 원자적인 방식으로 발생하는 경우에만 증가됩니다. 이 시스템에 사용할 수있는 시스템/아키텍처 관련 프리미티브가 있는지는 모르겠지만 C++ 11에서 구현하는 한 가지 방법은 다음과 같습니다.

std::shared_ptr<T> lock() { 
    if (!isInitialized) { 
     return std::shared_ptr<T>(); 
    } 
    std::atomic<int>& strong_ref_cnt = get_strong_ref_cnt_var_from_control_block(); 
    int old_cnt = strong_ref_cnt.load(); 
    while (old_cnt && !strong_ref_cnt.compare_exchange_weak(old_cnt, old_cnt + 1)) { 
     ; 
    } 
    if (old_cnt > 0) { 
     // create shared_ptr without touching the control block any further 
    } else { 
     // create empty shared_ptr 
    } 
} 

Answer 2

인터페이스들하지 않는다 "는 std::weak_ptr 및 std::shared_ptr 인터페이스는 원자 expired() ? shared_ptr<T>() : shared_ptr<T>(*this)는 다음과 같은 작업을 할 방법"을 참조하십시오. 구현에 내부적입니다. 실행 방법은 구현마다 다를 수 있습니다.

Answer 3

위 코드는 스레드로부터 안전한가요? int_ptr.reset(nullptr);으로 내가 아니에요 생각

는, 나는 표준 : : weak_ptr를 및 표준 : : shared_ptr의 인터페이스는 원자 다음 조작을 어떻게 이해할 수없는 std::weak_ptr int_ptr_weak = int_ptr;

에 대해 경주 expired() ? shared_ptr<T>() : shared_ptr<T>(*this)

이러한 작업은 원자가 아닙니다. expired()이 false를 반환 할 수 있지만 해당 값을 처리 할 때 더 이상 정확하지 않을 수 있습니다. 반면에 true를 반환하면 그 이후로 이 특정 인스턴스를 수정하지 않는 한 정확한 결과가 보장됩니다. 즉, 주어진 shared_ptr의 다른 사본에 대한 조작으로 인해 만료되지 않을 수 있습니다.

weak_ptr::lock() 구현은 expired()을 사용하지 않을 예정입니다. 원자 비교 - 교환과 같은 일을 할 것입니다. 여기서 강한 참조는 현재 숫자가 0보다 큰 경우에만 추가됩니다.

Answer 4

아니요, 코드가 스레드로부터 안전하지 않습니다. 주 스레드 (쓰기 작업)의 int_ptr.reset() 작업과 int_weak_ptr의 초기화는 int_ptr에서 th (읽기 작업 임)입니다.