Tại sao tôi std :: di chuyển một std :: shared_ptr?

Tôi đã xem qua mã nguồn Clang và tôi tìm thấy đoạn trích này:

void CompilerInstance::setInvocation(
    std::shared_ptr<CompilerInvocation> Value) {
  Invocation = std::move(Value);
}

Tại sao tôi muốn std::movemột std::shared_ptr?

Có bất kỳ điểm chuyển quyền sở hữu trên một tài nguyên được chia sẻ?

Tại sao tôi không làm điều này thay vào đó?

void CompilerInstance::setInvocation(
    std::shared_ptr<CompilerInvocation> Value) {
  Invocation = Value;
}

Tôi nghĩ rằng một điều mà các câu trả lời khác không nhấn mạnh đủ là điểm tốc độ .

std::shared_ptrsố tham chiếu là nguyên tử . tăng hoặc giảm số lượng tham chiếu đòi hỏi phải tăng hoặc giảm nguyên tử . Tốc độ này chậm hơn hàng trăm lần so với mức tăng / giảm không nguyên tử , chưa kể rằng nếu chúng ta tăng và giảm cùng một bộ đếm, chúng ta sẽ kết thúc với con số chính xác, gây lãng phí hàng tấn thời gian và tài nguyên trong quy trình.

Bằng cách di chuyển shared_ptrthay vì sao chép nó, chúng tôi "đánh cắp" số tham chiếu nguyên tử và chúng tôi vô hiệu hóa cái khác shared_ptr. "đánh cắp" số tham chiếu không phải là nguyên tử , và nó nhanh hơn hàng trăm lần so với việc sao chép shared_ptr(và gây ra sự tăng hoặc giảm tham chiếu nguyên tử ).

Xin lưu ý rằng kỹ thuật này được sử dụng hoàn toàn để tối ưu hóa. sao chép nó (như bạn đề xuất) cũng giống như chức năng tốt.

Bằng cách sử dụng, movebạn tránh tăng, và sau đó giảm ngay lập tức, số lượng cổ phiếu. Điều đó có thể giúp bạn tiết kiệm một số hoạt động nguyên tử đắt tiền về số lượng sử dụng.

Các hoạt động di chuyển (như công cụ di chuyển) std::shared_ptrrất rẻ , vì về cơ bản chúng là "đánh cắp con trỏ" (từ nguồn đến đích; chính xác hơn, toàn bộ khối điều khiển trạng thái bị "đánh cắp" từ nguồn đến đích, bao gồm cả thông tin đếm tham chiếu) .

Thay vào đó, sao chép các hoạt động khi std::shared_ptrgọi tăng số tham chiếu nguyên tử (nghĩa là không chỉ ++RefCounttrên một RefCountthành viên dữ liệu số nguyên , mà ví dụ như gọi InterlockedIncrementtrên Windows), tốn kém hơn so với chỉ ăn cắp con trỏ / trạng thái.

Vì vậy, phân tích động lực đếm ref của trường hợp này một cách chi tiết:

// shared_ptr<CompilerInvocation> sp;
compilerInstance.setInvocation(sp);

Nếu bạn chuyển sptheo giá trị và sau đó lấy một bản sao bên trong CompilerInstance::setInvocationphương thức, bạn có:

1. Khi nhập phương thức, shared_ptrtham số được sao chép được xây dựng: số lần tăng nguyên tử ref .
2. Bên trong cơ thể của phương pháp, bạn sao chép các shared_ptrtham số vào các thành viên dữ liệu: Ref đếm nguyên tử tăng .
3. Khi thoát khỏi phương thức, shared_ptrtham số bị hủy: ref đếm giảm nguyên tử .

Bạn có hai mức tăng nguyên tử và một lần giảm nguyên tử, với tổng số ba hoạt động nguyên tử .

Thay vào đó, nếu bạn truyền shared_ptrtham số theo giá trị và sau đó std::movebên trong phương thức (như được thực hiện đúng trong mã của Clang), bạn có:

1. Khi nhập phương thức, shared_ptrtham số được sao chép được xây dựng: số lần tăng nguyên tử ref .
2. Bên trong cơ thể của phương pháp, bạn std::movecác shared_ptrtham số vào các thành viên dữ liệu: số lượng ref không không thay đổi! Bạn chỉ đang ăn cắp con trỏ / trạng thái: không có hoạt động đếm số nguyên tử đắt tiền nào được tham gia.
3. Khi thoát khỏi phương thức, shared_ptrtham số bị hủy; nhưng vì bạn đã chuyển sang bước 2, nên không có gì để hủy, vì shared_ptrtham số không còn trỏ đến bất cứ điều gì nữa. Một lần nữa, không có sự suy giảm nguyên tử xảy ra trong trường hợp này.

Điểm mấu chốt: trong trường hợp này bạn chỉ nhận được một lần tăng số nguyên tử, tức là chỉ một thao tác nguyên tử .
Như bạn có thể thấy, điều này tốt hơn nhiều so với hai mức tăng nguyên tử cộng với một lần giảm nguyên tử (cho tổng số ba thao tác nguyên tử) cho trường hợp sao chép.

Sao chép shared_ptrliên quan đến việc sao chép con trỏ đối tượng trạng thái bên trong của nó và thay đổi số tham chiếu. Di chuyển nó chỉ liên quan đến việc hoán đổi con trỏ đến bộ đếm tham chiếu nội bộ và đối tượng sở hữu, vì vậy nó nhanh hơn.

Có hai lý do để sử dụng std :: move trong tình huống này. Hầu hết các phản hồi đề cập đến vấn đề tốc độ, nhưng bỏ qua vấn đề quan trọng là thể hiện ý định của mã rõ ràng hơn.

Đối với std :: shared_ptr, std :: di chuyển rõ ràng biểu thị việc chuyển quyền sở hữu của người được chỉ định, trong khi thao tác sao chép đơn giản sẽ thêm chủ sở hữu bổ sung. Tất nhiên, nếu chủ sở hữu ban đầu sau đó từ bỏ quyền sở hữu của họ (chẳng hạn như bằng cách cho phép std :: shared_ptr của họ bị hủy), thì việc chuyển quyền sở hữu đã được thực hiện.

Khi bạn chuyển quyền sở hữu với std :: move, rõ ràng điều gì đang xảy ra. Nếu bạn sử dụng một bản sao bình thường, rõ ràng hoạt động dự định là chuyển khoản cho đến khi bạn xác minh rằng chủ sở hữu ban đầu ngay lập tức từ bỏ quyền sở hữu. Như một phần thưởng, việc triển khai hiệu quả hơn là có thể, vì việc chuyển quyền sở hữu nguyên tử có thể tránh được trạng thái tạm thời khi số lượng chủ sở hữu tăng thêm một (và người tham gia thay đổi về số lượng tham chiếu).

Ít nhất với libstdc ++, bạn sẽ có được hiệu suất tương tự với di chuyển và gán vì operator=các cuộc gọi std::movetrên con trỏ đến. Xem: https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/ Shared_ptr.h # L384