【在Linux世界中追寻巨大的One Piece】多线程(三)

目录
1 -> Linux线程同步
1.1 -> 条件变量
1.2 -> 同步概念与竞态条件
1.3 -> 条件变量函数
1.4 -> 为什么pthread_cond_wait需要互斥量
1.5 -> 条件变量使用规范
2 -> 生产者消耗者模型
2.1 -> 为什么要使用生产者消耗者模型
2.2 -> 生产者消耗者模型优点
2.3 -> 基于BlockingQueue的生产者消耗者模型
2.4 -> C++ queue模仿阻塞队列的生产消耗模型
2.5 -> POSIX信号量
2.6 -> 基于环形队列的生产消耗模型
3 -> 线程池
3.1 -> 线程池概念
3.2 -> 线程池应用场景
3.3 -> 线程池示例
4 -> 线程安全的单例模式
4.1 -> 什么是单例模式
4.2 -> 单例模式的特点
4.3 -> 饿汉方式实现单例模式
4.4 -> 懒汉方式实现单例模式
4.5 -> 懒汉方式实现单例模式(线程安全版本)
5 -> STL，智能指针和线程安全
5.1 -> STL中的容器是否是线程安全的
5.2 -> 智能指针是否是线程安全的

---

1 -> Linux线程同步

1.1 -> 条件变量

• 当一个线程互斥地访问某个变量时，它大概发现在其它线程改变状态之前，它什么也做不了。
  
• 比方一个线程访问队列时，发现队列为空，它只能等待，直到其它线程将一个节点添加到队列中。这种环境就需要用到条件变量。
  

1.2 -> 同步概念与竞态条件

• 同步：在包管数据安全的条件下，让线程可以或许按照某种特定的顺序访问临界资源，从而有用制止饥饿标题，叫做同步。
  
• 竞态条件：因为时序标题，而导致步伐异常，我们称之为竞态条件。在线程场景下，这种标题不难理解。
  

1.3 -> 条件变量函数

初始化

1. int pthread_cond_init(pthread_cond_t* restrict cond, const pthread_condattr_t* restrict attr);
3. 参数：
4. cond：要初始化的条件变量
5. attr：NULL

复制代码

烧毁

1. int pthread_cond_destroy(pthread_cond_t* cond);

复制代码

等待条件满意

1. int pthread_cond_wait(pthread_cond_t* restrict cond, pthread_mutex_t* restrict mutex);
3. 参数：
4. cond：要在这个条件变量上等待
5. mutex：互斥量

复制代码

叫醒等待

1. int pthread_cond_broadcast(pthread_cond_t* cond);
2. int pthread_cond_signal(pthread_cond_t* cond);

复制代码

简朴案例

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <unistd.h>
5. #include <pthread.h>
7. pthread_cond_t cond;
8. pthread_mutex_t mutex;
10. void* r1(void* arg)
11. {
12.         while (1)
13.         {
14.                 pthread_cond_wait(&cond, &mutex);
15.                 printf("活动\n");
16.         }
17. }
19. void* r2(void* arg)
20. {
21.         while (1)
22.         {
23.                 pthread_cond_signal(&cond);
24.                 sleep(1);
25.         }
26. }
28. int main(void)
29. {
30.         pthread_t t1, t2;
32.         pthread_cond_init(&cond, NULL);
33.         pthread_mutex_init(&mutex, NULL);
35.         pthread_create(&t1, NULL, r1, NULL);
36.         pthread_create(&t2, NULL, r2, NULL);
38.         pthread_join(t1, NULL);
39.         pthread_join(t2, NULL);
41.         pthread_mutex_destroy(&mutex);
42.         pthread_cond_destroy(&cond);
43. }

复制代码

     [root@localhost linux]# ./a.out        活动        活动        活动    1.4 -> 为什么pthread_cond_wait需要互斥量

• 条件等待是线程间同步的一种手段，如果只有一个线程，条件不满意，一直等下去都不会满意，以是必须要有一个线程通过某些操纵，改变共享变量，使原先不满意的条件变得满意，而且友好的通知等待在条件变量上的线程。
  
• 条件不会无缘无端的突然变得满意，必然会牵涉到共享数据的变化。以是一定要用互斥锁来保护。没有互斥锁就无法安全的获取和修改共享数据。
  

• 按照上面的说法，设计出如下的代码：先上锁，发现条件不满意，解锁，然后等待在条件变量上就行了。
  

1. // 错误的设计
2. pthread_mutex_lock(&mutex);
3. while (condition_is_false)
4. {
5.         pthread_mutex_unlock(&mutex);
6.         //解锁之后，等待之前，条件可能已经满足，信号已经发出，但是该信号可能被错过
7.         pthread_cond_wait(&cond);
8.         pthread_mutex_lock(&mutex);
10. }
11. pthread_mutex_unlock(&mutex);

复制代码

• 由于解锁和等待不是原子操纵。调用解锁之后，pthread_cond_wait之前，如果已经有其他线程获取到互斥量，摒弃条件满意，发送了信号，那么pthread_cond_wait将错过这个信号，大概会导致线程永远阻塞在这个pthread_cond_wait。以是解锁和等待必须是一个原子操纵。
  
• int pthread_cond_wait(pthread_cond_t *cond，pthread_mutex_t *mutex)；进入该函数后，会去看条件量是否即是0，即是0，就把互斥量变成1，直到cond_wait返回，把条件量改成1，把互斥量恢复成原样。
  

1.5 -> 条件变量使用规范

• 等待条件代码
  

1. pthread_mutex_lock(&mutex);
2. while (条件为假）
3.         pthread_cond_wait(cond, mutex);
4. 修改条件
5. pthread_mutex_unlock(&mutex);

复制代码

• 给条件发送信号代码
  

1. pthread_mutex_lock(&mutex);
2. 设置条件为真
3. pthread_cond_signal(cond);
4. pthread_mutex_unlock(&mutex);

复制代码

2 -> 生产者消耗者模型

2.1 -> 为什么要使用生产者消耗者模型

生产者消耗者模式就是通过一个容器来解决生产者和消耗者的强耦合标题。生产者和消耗者相互之间不直接通讯，而通过阻塞队列来进行通讯，以是生产者生产完数据之后不消等待消耗者处理，直接扔给阻塞队列，消耗者不找生产者索要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，均衡了生产者和消耗者的处理能力。这个阻塞队列就是用来给生产者和消耗者解耦的。
2.2 -> 生产者消耗者模型优点

• 解耦
  
• 支持并发
  
• 支持忙闲不均
  

2.3 -> 基于BlockingQueue的生产者消耗者模型

在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消耗者模型的数据结构。其与普通的队列区别在于：当队列为空时，从队列获取元素的操纵将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操纵也会被阻塞，直到有元素被从队列中取出(以上的操纵都是基于不同的线程来说的，线程在对阻塞队列进程操纵时会被阻塞)。

2.4 -> C++ queue模仿阻塞队列的生产消耗模型

代码：

1. #include <iostream>
2. #include <queue>
3. #include <stdlib.h>
4. #include <pthread.h>
6. #define NUM 8
8. class BlockQueue
9. {
10. private:
11.         std::queue<int> q;
12.         int cap;
13.         pthread_mutex_t lock;
14.         pthread_cond_t full;
15.         pthread_cond_t empty;
17. private:
18.         void LockQueue()
19.         {
20.                 pthread_mutex_lock(&lock);
21.         }
23.         void UnLockQueue()
24.         {
25.                 pthread_mutex_unlock(&lock);
26.         }
28.         void ProductWait()
29.         {
30.                 pthread_cond_wait(&full, &lock);
31.         }
33.         void ConsumeWait()
34.         {
35.                 pthread_cond_wait(&empty, &lock);
36.         }
38.         void NotifyProduct()
39.         {
40.                 pthread_cond_signal(&full);
41.         }
43.         void NotifyConsume()
44.         {
45.                 pthread_cond_signal(&empty);
46.         }
48.         bool IsEmpty()
49.         {
50.                 return (q.size() == 0 ? true : false);
51.         }
53.         bool IsFull()
54.         {
55.                 return (q.size() == cap ? true : false);
56.         }
58. public:
59.         BlockQueue(int _cap = NUM) :cap(_cap)
60.         {
61.                 pthread_mutex_init(&lock, NULL);
62.                 pthread_cond_init(&full, NULL);
63.                 pthread_cond_init(&empty, NULL);
64.         }
66.         void PushData(const int& data)
67.         {
68.                 LockQueue();
69.                 while (IsFull())
70.                 {
71.                         NotifyConsume();
72.                         std::cout << "queue full, notify
73.                                 consume data, product stop." << std::endl;
74.                                 ProductWait();
75.                 }
77.                 q.push(data);
78.                 // NotifyConsume();
79.                 UnLockQueue();
80.         }
82.         void PopData(int& data)
83.         {
84.                 LockQueue();
85.                 while (IsEmpty())
86.                 {
87.                         NotifyProduct();
88.                         std::cout << "queue empty, notify
89.                                 product data, consume stop." << std::endl;
90.                                 ConsumeWait();
91.                 }
93.                 data = q.front();
94.                 q.pop();
95.                 // NotifyProduct();
96.                 UnLockQueue();
97.         }
99.         ~BlockQueue()
100.         {
101.                 pthread_mutex_destroy(&lock);
102.                 pthread_cond_destroy(&full);
103.                 pthread_cond_destroy(&empty);
104.         }
105. };
107. void* consumer(void* arg)
108. {
109.         BlockQueue* bqp = (BlockQueue*)arg;
110.         int data;
111.         for (; ; )
112.         {
113.                 bqp->PopData(data);
114.                 std::cout << "Consume data done : " << data <<
115.                         std::endl;
116.         }
117. }
119. //more faster
120. void* producter(void* arg)
121. {
122.         BlockQueue* bqp = (BlockQueue*)arg;
123.         srand((unsigned long)time(NULL));
124.         for (; ; )
125.         {
126.                 int data = rand() % 1024;
127.                 bqp->PushData(data);
128.                 std::cout << "Prodoct data done: " << data <<
129.                         std::endl;
130.                 // sleep(1);
131.         }
132. }
134. int main()
135. {
136.         BlockQueue bq;
138.         pthread_t c, p;
140.         pthread_create(&c, NULL, consumer, (void*)&bq);
141.         pthread_create(&p, NULL, producter, (void*)&bq);
143.         pthread_join(c, NULL);
144.         pthread_join(p, NULL);
146.         return 0;
147. }

复制代码

2.5 -> POSIX信号量

POSIX信号量和SystemV信号量作用相同，都是用于同步操纵，达到无冲突的访问共享资源目的。但POSIX可以用于线程间同步。
初始化信号量

1. #include <semaphore.h>
2. int sem_init(sem_t* sem, int pshared, unsigned int value);
4. 参数：
5. pshared : 0 表示线程间共享，非零表示进程间共享
6. value：信号量初始值

复制代码

烧毁信号量

1. int sem_destroy(sem_t* sem);

复制代码

等待信号量

1. 功能：等待信号量，会将信号量的值减 1
2. int sem_wait(sem_t * sem); //P()

复制代码

发布信号量

1. 功能：发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加 1。
2. int sem_post(sem_t * sem);//V()

复制代码

生产者-消耗者的例子是基于queue的，其空间可以动态分配，现在基于固定巨细的环形队列重写这个步伐(POSIX信号量)。
2.6 -> 基于环形队列的生产消耗模型

• 环形队列采用数组模仿，用模运算来模仿环状特性。
  

• 环形结构起始状态和结束状态都是一样的，不好判断为空或者为满，以是可以通过加计数器或者标记位来判断满或者空。另外也可以预留一个空的位置，作为满的状态。
  

• 但是现有的信号量这个计数器，是简朴的进行多进程间的同步过程。
  

1. #include <iostream>
2. #include <vector>
3. #include <stdlib.h>
4. #include <semaphore.h>
5. #include <pthread.h>
7. #define NUM 16
9. class RingQueue
10. {
11. private:
12.         std::vector<int> q;
13.         int cap;
14.         sem_t data_sem;
15.         sem_t space_sem;
16.         int consume_step;
17.         int product_step;
19. public:
20.         RingQueue(int _cap = NUM) :q(_cap), cap(_cap)
21.         {
22.                 sem_init(&data_sem, 0, 0);
23.                 sem_init(&space_sem, 0, cap);
24.                 consume_step = 0;
25.                 product_step = 0;
26.         }
28.         void PutData(const int& data)
29.         {
30.                 sem_wait(&space_sem); // P
31.                 q[consume_step] = data;
32.                 consume_step++;
33.                 consume_step %= cap;
34.                 sem_post(&data_sem); //V
35.         }
37.         void GetData(int& data)
38.         {
39.                 sem_wait(&data_sem);
40.                 data = q[product_step];
41.                 product_step++;
42.                 product_step %= cap;
43.                 sem_post(&space_sem);
44.         }
46.         ~RingQueue()
47.         {
48.                 sem_destroy(&data_sem);
49.                 sem_destroy(&space_sem);
50.         }
51. };
53. void* consumer(void* arg)
54. {
55.         RingQueue* rqp = (RingQueue*)arg;
56.         int data;
57.         for (; ; )
58.         {
59.                 rqp->GetData(data);
60.                 std::cout << "Consume data done : " << data << std::endl;
61.                 sleep(1);
62.         }
63. }
65. //more faster
66. void* producter(void* arg)
67. {
68.         RingQueue* rqp = (RingQueue*)arg;
69.         srand((unsigned long)time(NULL));
70.         for (; ; )
71.         {
72.                 int data = rand() % 1024;
73.                 rqp->PutData(data);
74.                 std::cout << "Prodoct data done: " << data << std::endl;
75.                 // sleep(1);
76.         }
77. }
79. int main()
80. {
81.         RingQueue rq;
83.         pthread_t c, p;
85.         pthread_create(&c, NULL, consumer, (void*)&rq);
86.         pthread_create(&p, NULL, producter, (void*)&rq);
88.         pthread_join(c, NULL);
89.         pthread_join(p, NULL);
91. }

复制代码

3 -> 线程池

3.1 -> 线程池概念

一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和团体性能。而线程池维护着多个线程，等待着监视管理者分配可并发实验的任务。这制止了在处理短时间任务时创建与烧毁线程的代价。线程池不仅可以或许包管内核的充分使用，还能防止太过调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络 sockets 等的数量。
3.2 -> 线程池应用场景

• 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求如许的任务，使用线程池技术黑白常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet毗连请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
  
• 对性能要求苛刻的应用，比如要求服务器灵敏相应客户请求。
  
• 担当突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池环境下，将产生大量线程，虽然理论上大部门操纵体系线程数量最大值不是标题，短时间内产生大量线程大概使内存到达极限，出现错误。
  

3.3 -> 线程池示例

threadpool.hpp

1. #ifndef __M_TP_H__
2. #define __M_TP_H__
4. #include <iostream>
5. #include <queue>
6. #include <pthread.h>
8. #define MAX_THREAD 5
10. typedef bool (*handler_t)(int);
12. class ThreadTask
13. {
14. private:
15.         int _data;
16.         handler_t _handler;
17. public:
18.         ThreadTask() :_data(-1), _handler(NULL) {}
20.         ThreadTask(int data, handler_t handler)
21.         {
22.                 _data = data;
23.                 _handler = handler;
24.         }
26.         void SetTask(int data, handler_t handler)
27.         {
28.                 _data = data;
29.                 _handler = handler;
30.         }
32.         void Run()
33.         {
34.                 _handler(_data);
35.         }
36. };
38. class ThreadPool
39. {
40. private:
41.         int _thread_max;
42.         int _thread_cur;
43.         bool _tp_quit;
44.         std::queue<ThreadTask*> _task_queue;
45.         pthread_mutex_t _lock;
46.         pthread_cond_t _cond;
48. private:
49.         void LockQueue()
50.         {
51.                 pthread_mutex_lock(&_lock);
52.         }
54.         void UnLockQueue()
55.         {
56.                 pthread_mutex_unlock(&_lock);
57.         }
59.         void WakeUpOne()
60.         {
61.                 pthread_cond_signal(&_cond);
62.         }
64.         void WakeUpAll()
65.         {
66.                 pthread_cond_broadcast(&_cond);
67.         }
69.         void ThreadQuit()
70.         {
71.                 _thread_cur--;
72.                 UnLockQueue();
73.                 pthread_exit(NULL);
74.         }
76.         void ThreadWait()
77.         {
78.                 if (_tp_quit)
79.                 {
80.                         ThreadQuit();
81.                 }
82.                 pthread_cond_wait(&_cond, &_lock);
83.         }
85.         bool IsEmpty()
86.         {
87.                 return _task_queue.empty();
88.         }
90.         static void* thr_start(void* arg)
91.         {
92.                 ThreadPool* tp = (ThreadPool*)arg;
93.                 while (1)
94.                 {
95.                         tp->LockQueue();
96.                         while (tp->IsEmpty())
97.                         {
98.                                 tp->ThreadWait();
99.                         }
101.                         ThreadTask* tt;
102.                         tp->PopTask(&tt);
103.                         tp->UnLockQueue();
104.                         tt->Run();
106.                         delete tt;
107.                 }
109.                 return NULL;
110.         }
112. public:
113.         ThreadPool(int max = MAX_THREAD) :_thread_max(max),
114.                 _thread_cur(max),
115.                 _tp_quit(false)
116.         {
117.                 pthread_mutex_init(&_lock, NULL);
118.                 pthread_cond_init(&_cond, NULL);
119.         }
121.         ~ThreadPool()
122.         {
123.                 pthread_mutex_destroy(&_lock);
124.                 pthread_cond_destroy(&_cond);
125.         }
127.         bool PoolInit()
128.         {
129.                 pthread_t tid;
130.                 for (int i = 0; i < _thread_max; i++)
131.                 {
132.                         int ret = pthread_create(&tid, NULL, thr_start,
133.                                 this);
134.                         if (ret != 0)
135.                         {
136.                                 std::cout << "create pool thread error\n";
138.                                 return false;
139.                         }
140.                 }
142.                 return true;
143.         }
145.         bool PushTask(ThreadTask* tt)
146.         {
147.                 LockQueue();
148.                 if (_tp_quit)
149.                 {
150.                         UnLockQueue();
151.                         return false;
152.                 }
154.                 _task_queue.push(tt);
155.                 WakeUpOne();
156.                 UnLockQueue();
158.                 return true;
159.         }
161.         bool PopTask(ThreadTask** tt)
162.         {
163.                 *tt = _task_queue.front();
164.                 _task_queue.pop();
166.                 return true;
167.         }
169.         bool PoolQuit()
170.         {
171.                 LockQueue();
172.                 _tp_quit = true;
173.                 UnLockQueue();
174.                 while (_thread_cur > 0)
175.                 {
176.                         WakeUpAll();
177.                         usleep(1000);
178.                 }
180.                 return true;
181.         }
183. };
184. #endif

复制代码

main.cpp

1. bool handler(int data)
2. {
3.         srand(time(NULL));
4.         int n = rand() % 5;
5.         printf("Thread: %p Run Tast: %d--sleep %d sec\n", pthread_self(), data, n);
6.         sleep(n);
8.         return true;
9. }
11. int main()
12. {
13.         int i;
14.         ThreadPool pool;
15.         pool.PoolInit();
16.         for (i = 0; i < 10; i++)
17.         {
18.                 ThreadTask* tt = new ThreadTask(i, handler);
19.                 pool.PushTask(tt);
20.         }
22.         pool.PoolQuit();
24.         return 0;
25. }

复制代码

     g++ -std=c++0x test.cpp -o test -pthread -lrt    4 -> 线程安全的单例模式

4.1 -> 什么是单例模式

单例模式(Singleton Pattern)是一种设计模式，旨在确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式常用于管理共享资源，如配置信息、线程池、缓存等。单例模式的核心头脑是控制对象的实例化过程，使得在整个应用步伐中只有一个实例存在，而且所有对该实例的访问都通过同一个访问点进行。
4.2 -> 单例模式的特点

• 唯一性：单例模式确保一个类只有一个实例。这意味着在整个应用步伐的生命周期中，无论在何处调用该类的实例，都将返回同一个对象。
  
• 全局访问点：单例模式提供了一个全局访问点，通常是一个静态方法，用于获取该类的唯一实例。这使得在步伐的任何地方都可以或许方便地访问该实例。
  
• 延迟初始化：单例模式的实例通常在第一次被请求时才会创建，这有助于节流资源。这种延迟初始化的特性也被称为懒加载(Lazy Initialization)。
  
• 线程安全：在多线程环境下，单例模式需要确保其唯一性和全局访问的正确性。这通常通过同步机制来实现，如使用锁或其他并发控制手段。
  
• 控制实例化：单例模式的构造函数通常是私有的，这防止了外部代码通过通例的构造函数创建新的实例。
  
• 可扩展性：单例模式可以通过继承或其他方式进行扩展，以满意不同的应用需求。
  
• 资源管理：单例模式常用于管理共享资源，如数据库毗连、线程池、配置信息等，确保这些资源在整个应用步伐中只有一个实例，从而提高资源的使用效率和管理便利性。
  
• 性能优化：由于单例模式只创建一个实例，因此可以减少内存开销和提高性能，特别是在处理大量数据或频仍访问的对象时。
  
• 简化代码结构：单例模式可以简化代码结构，因为它提供了一个单一的、全局的访问点，使得代码的维护和理解更加容易。
  
• 适用场景：单例模式适用于那些在整个应用步伐中只需要一个实例的场景，如日志记录器、配置管理器、数据库毗连池等。
  

4.3 -> 饿汉方式实现单例模式

1. template <typename T>
2. class Singleton
3. {
4.         static T data;
5. public:
6.         static T* GetInstance()
7.         {
8.                 return &data;
9.         }
10. };

复制代码

只要通过Singleton这个包装类来使用T对象，则一个进程中只有一个T对象的实例。
4.4 -> 懒汉方式实现单例模式

1. template <typename T>
2. class Singleton
3. {
4.         static T* inst;
5. public:
6.         static T* GetInstance()
7.         {
8.                 if (inst == NULL)
9.                 {
10.                         inst = new T();
11.                 }
12.                 return inst;
13.         }
14. };

复制代码

存在一个严重的标题，线程不安全。
第一个调用GetInstance时，如果两个线程同时调用，大概会创建出两份T对象的实例。
但是后续再次调用，就没有标题了。

4.5 -> 懒汉方式实现单例模式(线程安全版本)

1. // 懒汉模式, 线程安全
2. template <typename T>
3. class Singleton
4. {
5.         volatile static T* inst; // 需要设置 volatile 关键字, 否则可能被编译器优化.
6.         static std::mutex lock;
8. public:
9.         static T* GetInstance()
10.         {
11.                 if (inst == NULL)
12.                 { // 双重判定空指针, 降低锁冲突的概率, 提高性能.
13.                         lock.lock(); // 使用互斥锁, 保证多线程情况下也只调用一次 new.
14.                         if (inst == NULL)
15.                         {
16.                                 inst = new T();
17.                         }
18.                         lock.unlock();
19.                 }
21.                 return inst;
22.         }
23. };

复制代码

注意：

• 加锁解锁的位置
  
• 双重if判断，制止不必要的锁竞争
  
• volatile关键字防止过分优化
  

5 -> STL，智能指针和线程安全

5.1 -> STL中的容器是否是线程安全的

不是。
缘故原由是，STL的设计初衷是将性能挖掘到极致，而一旦涉及到加锁包管线程安全，会对性能造成巨大的影响。
而且对于不同的容器，加锁方式的不同，性能大概也不同(比方hash表的锁表和锁桶)。
因此STL默认不是线程安全。如果需要在多线程环境下使用，往往需要调用者自行包管线程安全。
5.2 -> 智能指针是否是线程安全的

对于unique_ptr，由于只是在当前代码块范围内见效，因此不涉及线程安全标题。
对于shared_ptr，多个对象需要共用一个引用计数变量，以是会存在线程安全标题。但是标准库实现的时间考虑到了这个标题，基于原子操纵(CAS)的方式包管shared_ptr可以或许高效，原子的操纵引用计数。

---

感谢各位大佬支持！！！

互三啦！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。