std :: shared_ptr iş parçacığı güvenliği açıklandı

Okuduğum http://gcc.gnu.org/onlinedocs/libstdc++/manual/shared_ptr.html ve bazı iş parçacığı güvenlik sorunları hala benim için açık değildir:

1. Standart, referans sayımının iş parçacığı açısından güvenli olduğunu ve platformdan bağımsız olduğunu garanti eder, değil mi?
2. Benzer sorun - standart, yalnızca bir iş parçacığının (son referansı tutan) paylaşılan nesnede silme çağrısı yapacağını garanti eder, değil mi?
3. shared_ptr, içinde depolanan nesne için herhangi bir iş parçacığı güvenliğini garanti etmez mi?

DÜZENLE:

Sözde kod:

// Thread I
shared_ptr<A> a (new A (1));

// Thread II
shared_ptr<A> b (a);

// Thread III
shared_ptr<A> c (a);

// Thread IV
shared_ptr<A> d (a);

d.reset (new A (10));

İş parçacığı IV'teki reset () çağrısı, ilk iş parçacığında oluşturulan A sınıfının önceki örneğini silecek ve onu yeni örnekle değiştirecek mi? Ayrıca IV iş parçacığında reset () çağrıldıktan sonra diğer evreler sadece yeni oluşturulan nesneyi görecekler mi?

Diğerlerinin de belirttiği gibi, orijinal 3 sorunuzu doğru bir şekilde çözdünüz.

Ama düzenlemenizin son kısmı

İş parçacığı IV'teki reset () çağrısı, ilk iş parçacığında oluşturulan A sınıfının önceki örneğini silecek ve onu yeni örnekle değiştirecek mi? Ayrıca IV iş parçacığında reset () çağrıldıktan sonra diğer evreler sadece yeni oluşturulan nesneyi görecekler mi?

yanlış. Sadece dyeni işaret eder A(10)ve a, bve corijinaline noktaya devam edecektir A(1). Bu, aşağıdaki kısa örnekte açıkça görülebilir.

#include <memory>
#include <iostream>
using namespace std;

struct A
{
  int a;
  A(int a) : a(a) {}
};

int main(int argc, char **argv)
{
  shared_ptr<A> a(new A(1));
  shared_ptr<A> b(a), c(a), d(a);

  cout << "a: " << a->a << "\tb: " << b->a
     << "\tc: " << c->a << "\td: " << d->a << endl;

  d.reset(new A(10));

  cout << "a: " << a->a << "\tb: " << b->a
     << "\tc: " << c->a << "\td: " << d->a << endl;
                                                                                                                 
  return 0;                                                                                                          
}

(Açıkçası, herhangi bir iş parçacığı ile uğraşmadım: bu, shared_ptr::reset()davranışı etkilemez .)

Bu kodun çıktısı

a: 1 b: 1 c: 1 d: 1

a: 1 b: 1 c: 1 d: 10

1. Doğru, shared_ptrreferans sayma değerinin atomik artışlarını / azalmalarını kullanın.

2. Standart, paylaşılan bir nesnede yalnızca bir iş parçacığının silme operatörünü çağıracağını garanti eder. Paylaşılan göstericinin kopyasını silen son iş parçacığının sil'i çağıran kişi olacağını özellikle belirtip belirtmediğinden emin değilim (muhtemelen pratikte durum böyle olacaktır).

3. Hayır yok, içinde depolanan nesne aynı anda birden fazla iş parçacığı tarafından düzenlenebilir.

DÜZENLEME: Biraz takip, eğer paylaşılan işaretçilerin genel olarak nasıl çalıştığına dair bir fikir edinmek istiyorsanız, boost::shared_ptrkaynağa bakmak isteyebilirsiniz : http://www.boost.org/doc/libs/1_37_0/boost/shared_ptr.hpp .

std::shared_ptr iş parçacığı güvenli değil.

Paylaşılan bir işaretçi, biri nesneye ve diğeri de kontrol bloğuna (ref sayacını tutan, zayıf işaretçilerle bağlantılar ...) olmak üzere iki işaretçi çiftidir.

Birden fazla std :: shared_ptr olabilir ve referans sayacını değiştirmek için kontrol bloğuna her eriştiklerinde iş parçacığı açısından güvenlidir, ancak std::shared_ptrkendisi iş parçacığı güvenli veya atomik değildir.

std::shared_ptrBaşka bir iş parçacığı onu kullanırken yeni bir nesne atarsanız , yeni nesne işaretçisi ile sonuçlanabilir ancak yine de eski nesnenin kontrol bloğuna bir işaretçi kullanır => CRASH.