（Ab）shared_ptrを参照カウンタとして使用

Question

最近私は狡猾な計画（tm：P）を考えました 私のプログラムで設定の構造を更新しなければなりません。設定構造体は複数の関数によって使用され、それらの関数はすべて複数のスレッドによって呼び出されます。 古い設定の構造体を解放するのがいつ安全であるかを知るために、参照カウンタが必要です。 これは正しい方法ですか？ コードを慎重に読んでいない場合は、共有ポインターに関してはこのような悪用を行うと間違いを犯すのは簡単です（信頼してください）。 編集：重要な部分については言及しません。私はこの実装がrefSetを0に落とさないようにしていると思います。なぜなら、私はupdateSettings（）で初期化し、再度呼び出されるまで落とされないからです（そして、myFucntionはメモリの2つの設定のうちのもう1つを使います）。

#include<memory> 
#include <cstdio> 
#include <iostream> 
#include <vector> 
using namespace std; 
struct STNGS 
{ 
    int i; 
    vector<double> v; 
}; 
static int CUR_STNG=0; 
shared_ptr<STNGS> stngsArray[2]; 
int myFunction() //called by multiple threads 
{ 
    shared_ptr<STNGS> pStngs=stngsArray[CUR_STNG]; 
    STNGS& stngs=*pStngs; 
    //do some stuff using stngs 

} 

void updateSettings() 
{ 
    auto newIndex=(CUR_STNG+1)%2; 
    stngsArray[newIndex].reset(new STNGS); 
    CUR_STNG=newIndex; 
} 
void initialize() 
{ 
    auto newIndex=CUR_STNG; 
    stngsArray[newIndex].reset(new STNGS); 
    CUR_STNG=newIndex; 
} 
int main() 
{ 
    initialize(); 
    //launch bunch of threads that are calling myFunction 
    while(true) 
    { 
     //call updateSettings every 15 seconds 
    } 
} 

編集：私は、コードを更新し、コメントからのフィードバックを使用して：

#include<memory> 
#include <cstdio> 
#include <iostream> 
#include <vector> 
using namespace std; 
static const int N_STNG_SP=4; 
static int CUR_STNG=0; 
struct STNGS 
{ 
    int i; 
    vector<double> v; 
    STNGS() 
    { 
     for (int i=0;i<10;++i) 
      v.push_back(42); 
    } 
}; 
shared_ptr<STNGS> stngs[N_STNG_SP]; 
int myFunction() //called by multiple threads 
{ 
    shared_ptr<STNGS> pStngs=stngs[CUR_STNG]; 
    STNGS& stngs=*pStngs; 
    //do some stuff using stngs 
} 

void updateSettings() 
{ 
    auto pStng=new STNGS; 
    //fill *pStng 
    int newVer=(CUR_STNG+1)%N_STNG_SP; 
    stngs[newVer].reset(pStng); 
    CUR_STNG=newVer; 
} 
void initialize() 
{ 
    auto pStng=new STNGS; 
    //fill *pStng 
    int newVer=(CUR_STNG+1)%N_STNG_SP; 
    stngs[newVer].reset(pStng); 
    CUR_STNG=newVer; 
} 
int main() 
{ 
    initialize(); 
    //launch bunch of threads that are calling myFunction 
    while(true) 
    { 
     //call updateSettings every 15 seconds 
     updateSettings(); 
    } 
} 

Answer 1

私はこのコードを信頼しないでしょう。私はそれが2つの参照カウントを除いて、異なるスレッドによって共有されるすべてのメモリ上の適切なメモリ障壁が欠けていると信じています。

これは私にとってshared_mutexの良いアプリケーションのようです。

編集：

20.7.2.2 [util.smartptr.shared]/P4は言う：データ競合の 存在を決定する目的のため

、部材 機能がアクセスしなければなりません shared_ptrオブジェクトとweak_ptrオブジェクトだけを変更してください。 オブジェクトは参照するオブジェクトではなく、 を参照してください。 shared_ptrのに

同時アクセス：

しかし、代わりにshared_mutexを使用するのではなく、別のオプションは、20.7.2.5のshared_ptrアトミックアクセス[util.smartptr.shared.atomic]でAPIを使用するのが良いかもしれません 複数のスレッドのオブジェクトが のアクセス権を持つ場合は、 のデータ競合を導入し、そのインスタンスは の最初の引数として渡されます。

template<class T> 
    bool atomic_is_lock_free(const shared_ptr<T>* p); 
template<class T> 
    shared_ptr<T> atomic_load(const shared_ptr<T>* p); 
template<class T> 
    shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo); 
template<class T> 
    void atomic_store(shared_ptr<T>* p, shared_ptr<T> r); 
template<class T> 
    void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 
template<class T> 
    shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r); 
template<class T> 
    shared_ptr<T> 
    atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 
template<class T> 
    bool 
    atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 
template<class T> 
    bool 
    atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 
template<class T> 
    bool 
    atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 
              shared_ptr<T> w, memory_order success, 
              memory_order failure); 
template<class T> 
    bool 
    atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 
              shared_ptr<T> w, memory_order success, 
              memory_order failure); 

shared_mutexは、権利を取得することが容易になります。しかし、atomic shared_ptr APIは、より高いパフォーマンスのソリューションをもたらすかもしれません。

アップデート：ここで

がshared_mutexソリューションのためのテストされていないコードは（ノートshared_mutexがSTDではなく、サードパーティのライブラリである）である：ここでは

struct STNGS 
{ 
    int i; 
    vector<double> v; 
    ting::shared_mutex m; 
}; 

STNGS stngs; 

int myFunction() //called by multiple threads 
{ 
    shared_lock<shared_mutex> _(stngs.m); 
    //do some stuff using stngs 
    return 0; 
} 

void updateSettings() 
{ 
    unique_lock<shared_mutex> _(stngs.m); 
    //fill stngs 
} 

void initialize() 
{ 
    //fill stngs 
} 

は原子の負荷を使用してテストされていないコードであります/ shared_ptrの関数を格納する：

struct STNGS 
{ 
    int i; 
    vector<double> v; 
}; 

shared_ptr<STNGS> pStng; 

int myFunction() //called by multiple threads 
{ 
    shared_ptr<STNGS> stngs = atomic_load(&pStng); 
    //do some stuff using *stngs 
    return 0; 
} 

void updateSettings() 
{ 
    shared_ptr<STNGS> newStng(new STNGS); 
    //fill *newStng 
    atomic_store(&pStng, newStng); 
} 

void initialize() 
{ 
    pStng.reset(new STNGS); 
    //fill *pStng 
}