std :: shared_ptr thread an toàn được giải thích

Tôi đang đọc http://gcc.gnu.org/onlineocs/libstdc++/manual/shared_ptr.html và tôi vẫn chưa rõ một số vấn đề về an toàn chuỗi:

1. Tiêu chuẩn đảm bảo rằng việc đếm tham chiếu được xử lý an toàn cho chuỗi và nó độc lập với nền tảng, phải không?
2. Vấn đề tương tự - tiêu chuẩn đảm bảo rằng chỉ một luồng (giữ tham chiếu cuối cùng) sẽ gọi xóa trên đối tượng được chia sẻ, phải không?
3. shared_ptr không đảm bảo an toàn luồng nào cho đối tượng được lưu trữ trong đó?

BIÊN TẬP:

Mã giả:

// 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));

Gọi reset () trong luồng IV sẽ xóa cá thể trước đó của lớp A được tạo trong luồng đầu tiên và thay thế nó bằng cá thể mới? Hơn nữa sau khi gọi reset () trong luồng IV các luồng khác sẽ chỉ thấy đối tượng mới được tạo?

Như những người khác đã chỉ ra, bạn đã hiểu đúng về 3 câu hỏi ban đầu của mình.

Nhưng phần cuối của bản chỉnh sửa của bạn

Gọi reset () trong luồng IV sẽ xóa cá thể trước đó của lớp A được tạo trong luồng đầu tiên và thay thế nó bằng cá thể mới? Hơn nữa sau khi gọi reset () trong luồng IV các luồng khác sẽ chỉ thấy đối tượng mới được tạo?

là không chính xác. Chỉ dsẽ trỏ đến mới A(10), và a, bvà csẽ tiếp tục đến thời điểm với bản gốc A(1). Có thể thấy rõ điều này trong ví dụ ngắn sau đây.

#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;                                                                                                          
}

(Rõ ràng, tôi không bận tâm đến bất kỳ luồng nào: điều đó không ảnh hưởng đến shared_ptr::reset()hành vi.)

Đầu ra của mã này là

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

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

1. Đúng, shared_ptrs sử dụng tăng / giảm nguyên tử của một giá trị đếm tham chiếu.

2. Tiêu chuẩn đảm bảo chỉ một luồng sẽ gọi toán tử xóa trên một đối tượng được chia sẻ. Tôi không chắc liệu nó có chỉ định cụ thể luồng cuối cùng xóa bản sao của con trỏ được chia sẻ hay không sẽ là luồng gọi xóa (có thể trong thực tế sẽ là trường hợp này).

3. Không, không, đối tượng được lưu trữ trong đó có thể được chỉnh sửa đồng thời bởi nhiều luồng.

CHỈNH SỬA: Theo dõi nhẹ, nếu bạn muốn có ý tưởng về cách con trỏ được chia sẻ hoạt động nói chung, bạn có thể muốn xem boost::shared_ptrnguồn: http://www.boost.org/doc/libs/1_37_0/boost/shared_ptr.hpp .

std::shared_ptr không phải là chủ đề an toàn.

Con trỏ dùng chung là một cặp gồm hai con trỏ, một con trỏ tới đối tượng và một con trỏ tới khối điều khiển (giữ bộ đếm tham chiếu, liên kết đến con trỏ yếu ...).

Có thể có nhiều std :: shared_ptr và bất cứ khi nào chúng truy cập vào khối điều khiển để thay đổi bộ đếm tham chiếu, nó an toàn theo luồng nhưng std::shared_ptrbản thân nó KHÔNG an toàn luồng hoặc nguyên tử.

Nếu bạn gán một đối tượng mới std::shared_ptrtrong một thời gian luồng khác sử dụng nó, nó có thể kết thúc với con trỏ đối tượng mới nhưng vẫn sử dụng một con trỏ đến khối điều khiển của đối tượng cũ => CRASH.