std::shared_ptr 的线程安全性 & 在多线程中的使用注意事项

Posted on In Word count in article: 1.5k Reading time ≈ 5 mins.

我们在讨论 std::shared_ptr 线程安全时，讨论的是什么？

在讨论之前，我们先理清楚这样的一个简单但却容易混淆的逻辑。 std::shared_ptr 是个类模版，无法孤立存在的，因此实际使用中，我们都是使用他的具体模版类。这里使用 std::shared_ptr 来举例，我们讨论的时候，其实上是在讨论 std::shared_ptr 的线程安全性，并不是 SomeType 的线程安全性。

那我们在讨论某个操作是否线程安全的时候，也需要看具体的代码是作用在 std::shared_ptr 上，还是 SomeType 上。

举个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <memory>

struct SomeType {
  void DoSomething() {
    some_value++;
  }

  int some_value;
};

int main() {
  std::shared_ptr<SomeType> ptr;
  ptr->DoSomething();
  return 0;
}

这里例子中，如果 ptr->DoSomething () 是运行在多线程中，讨论它是否线程安全，如何进行判断呢？

首先它可以展开为 ptr.operator->()->DoSomething()，拆分为两步：

  1. ptr.operator->() 这个是作用在 ptr 上，也就是 std::shared_ptr 上，因此要看 std::shared_ptr->() 是否线程安全，这个问题后面会详细来说
  2. ->DoSomething () 是作用在 SomeType* 上，因此要看 SomeType::DoSomething () 函数是否线程安全，这里显示是非线程安全的，因为对 some_value 的操作没有加锁，也没有使用 atomic 类型，多线程访问就出现未定义行为（UB）

std::shared_ptr 线程安全性

我们来看看 cppreference 里是怎么描述的:

All member functions (including copy constructor and copy assignment) can be called by multiple threads on different instances of shared_ptr without additional synchronization even if these instances are copies and share ownership of the same object.

If multiple threads of execution access the same instance of shared_ptr without synchronization and any of those accesses uses a non-const member function of shared_ptr then a data race will occur; the shared_ptr overloads of atomic functions can be used to prevent the data race.

我们可以得到下面的结论：

  1. 多线程环境中，对于持有相同裸指针的 std::shared_ptr 实例，所有成员函数的调用都是线程安全的。
    • 当然，对于不同的裸指针的 std::shared_ptr 实例，更是线程安全的
    • 这里的 “成员函数” 指的是 std::shared_ptr 的成员函数，比如 get ()、reset ()、 operrator->() 等）
  2. 多线程环境中，对于同一个 std::shared_ptr 实例，只有访问 const 的成员函数，才是线程安全的，对于非 const 成员函数，是非线程安全的，需要加锁访问。

首先来看一下 std::shared_ptr 的所有成员函数，只有前 3 个是 non-const 的，剩余的全是 const 的：

成员函数 是否 const
operator= non-const
reset non-const
swap non-const
get const
operator*、operator-> const
operator const
use_count const
unique(until C++20) const
operator bool const
owner_before const
use_count const

我们来看两个例子
例 1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <memory>
#include <thread>
#include <vector>
#include <atomic>
using namespace std;

struct SomeType {
  void DoSomething() {
    some_value++;
  }

  int some_value;
};

int main(int argc, char *argv[]) {
  auto test = std::make_shared<SomeType>();
  std::vector<std::thread> operations;
  for (int i = 0; i < 10000; i++) {
    std::thread([=]() mutable {  //<<--
      auto n = std::make_shared<SomeType>();
      test.swap(n);
    }).detach();
  }

  using namespace std::literals::chrono_literals;
  std::this_thread::sleep_for(5s);
  return 0;
}

例 2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <memory>
#include <thread>
#include <vector>
#include <atomic>
using namespace std;

struct SomeType {
  void DoSomething() {
    some_value++;
  }

  int some_value;
};

int main(int argc, char *argv[]) {
  auto test = std::make_shared<SomeType>();
  std::vector<std::thread> operations;
  for (int i = 0; i < 10000; i++) {
    std::thread([&]() mutable {  // <<---
      auto n = std::make_shared<SomeType>();
      test.swap(n);
    }).detach();
  }

  using namespace std::literals::chrono_literals;
  std::this_thread::sleep_for(5s);
  return 0;
}

这两个的区别只有传入到 std::thread 的 lambda 的捕获类型，一个是 capture by copy, 后者是 capture by reference，哪个会有线程安全问题呢？

根据刚才的两个结论，显然例 1 是没有问题的，因为每个 thread 对象都有一份 test 的 copy，因此访问任意成员函数都是线程安全的。 例 2 是有数据竞争存在的，因为所有 thread 都共享了同一个 test 的引用，根据刚才的结论 2，对于同一个 std::shared_ptr 对象，多线程访问 non-const 的函数是非线程安全的。
这个的 swap 改为 reset 也一样是非线程安全的，但如果改为 get () 就是线程安全的。

这里我们打开 Thread Sanitizer 编译例 2（clang 下是 -fsanitize=thread 参数），运行就会 crash 并告诉我们出现数据竞争的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
==================
WARNING: ThreadSanitizer: data race (pid=11868)
  Read of size 8 at 0x00016ba5f110 by thread T2:
    #0 std::__1::enable_if<(is_move_constructible<SomeType*>::value) && (is_move_assignable<SomeType*>::value), void>::type std::__1::swap<SomeType*>(SomeType*&, SomeType*&) swap.h:38 (Untitled 4:arm64+0x1000061a8)
    #1 std::__1::shared_ptr<SomeType>::swap(std::__1::shared_ptr<SomeType>&) shared_ptr.h:1045 (Untitled 4:arm64+0x100006140)
    #2 main::$_0::operator()() Untitled 4.cpp:22 (Untitled 4:arm64+0x1000060d4)
    #3 decltype(static_cast<main::$_0>(fp)()) std::__1::__invoke<main::$_0>(main::$_0&&) type_traits:3918 (Untitled 4:arm64+0x100005fc8)
    #4 void std::__1::__thread_execute<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, main::$_0>(std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, main::$_0>&, std::__1::__tuple_indices<>) thread:287 (Untitled 4:arm64+0x100005ec4)
    #5 void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, main::$_0> >(void*) thread:298 (Untitled 4:arm64+0x100004f90)

  Previous write of size 8 at 0x00016ba5f110 by thread T1:
    #0 std::__1::enable_if<(is_move_constructible<SomeType*>::value) && (is_move_assignable<SomeType*>::value), void>::type std::__1::swap<SomeType*>(SomeType*&, SomeType*&) swap.h:39 (Untitled 4:arm64+0x1000061f0)
    #1 std::__1::shared_ptr<SomeType>::swap(std::__1::shared_ptr<SomeType>&) shared_ptr.h:1045 (Untitled 4:arm64+0x100006140)
    #2 main::$_0::operator()() Untitled 4.cpp:22 (Untitled 4:arm64+0x1000060d4)
    #3 decltype(static_cast<main::$_0>(fp)()) std::__1::__invoke<main::$_0>(main::$_0&&) type_traits:3918 (Untitled 4:arm64+0x100005fc8)
    #4 void std::__1::__thread_execute<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, main::$_0>(std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, main::$_0>&, std::__1::__tuple_indices<>) thread:287 (Untitled 4:arm64+0x100005ec4)
    #5 void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, main::$_0> >(void*) thread:298 (Untitled 4:arm64+0x100004f90)
...

SUMMARY: ThreadSanitizer: data race swap.h:38 in std::__1::enable_if<(is_move_constructible<SomeType*>::value) && (is_move_assignable<SomeType*>::value), void>::type std::__1::swap<SomeType*>(SomeType*&, SomeType*&)

...

ThreadSanitizer: reported 4 warnings
Terminated due to signal: ABORT TRAP (6)

从错误信息中可以清晰地看到出现的数据竞争，在 22 行，也就是调用 swap () 的行。
如果确实需要在多线程环境下对同一 std::shared_ptr 实例做 swap () 操作，可以调用 atomic 对 std::shared_ptr 的重载函数，如：

1
2
3
template< class T >
std::shared_ptr<T> atomic_exchange( std::shared_ptr<T>* p,
                                    std::shared_ptr<T> r);