shared_ptr线程安全问题

 

shared_ptr 是引用计数型（reference counting）智能指针，几乎所有的实现都采用在堆（heap）上放个计数值（count）的办法。

官方对shared_ptr基本介绍： http://en.cppreference.com/w/cpp/memory/shared_ptr

madn：https://docs.microsoft.com/en-us/cpp/standard-library/shared-ptr-class?view=vs-2019

---

需要从两个层面进行考虑其线程安全性：

1） shared_ptr本身的线程安全性，例如，引用计数的正确性。
shared_ptr的引用计数是线程安全的，这是由库内部实现的。 如果，让程序员再去维护引用计算的安全性，那这个东西就太不好用了!

另外，多线程下，由于shared_ptr需要维护引用计数的安全，这会造成一定的开销（最新的实现可能已经使用了lock-free的方式了）。 

 

2）shared_ptr所托管的对象的线程安全性。
shared_ptr并不会改变其托管的对象的本身的线程安全性。

 

---

例1： 多个线程对同一个shared_ptr对象进行改写(改变其指向的资源)操作时，不安全!

https://stackoverflow.com/questions/14482830/stdshared-ptr-thread-safety

// In main()
shared_ptr<myClass> global_instance = make_shared<myClass>();
// (launch all other threads AFTER global_instance is fully constructed)


//In thread 2
global_instance = make_shared<myClass>();

定义一个全局变量global_instance,其可以被所有其他的线程访问。上面线程2胆大包天地改了全局变量的值，从而会影响到其他使用这个全局变量的线程。   -- 不仅仅是shared_ptr，对于其他类型的变量都不能这样子搞~
 

这种情况是安全的： 很多个线程存在，但是仅仅去读global_instance。

 

 

例2： shared_ptr所托管的对象的线程安全性需要coder自己保证：

The thread-safety of the shared_ptr<> instances only applies to managing shared_ptr<> instances which were initialized from each other, not what they're pointing to.

shared_ptr<int> global_instance = make_shared<int>(0);

void thread_fcn();

int main(int argc, char** argv)
{
    thread thread1(thread_fcn);
    thread thread2(thread_fcn);
    ...
    thread thread10(thread_fcn);

    chrono::milliseconds duration(10000);
    this_thread::sleep_for(duration);

    return;
}

void thread_fcn()
{
    // This is thread-safe and will work fine, though it's useless.  Many
    // short-lived pointers will be created and destroyed.
    for(int i = 0; i < 10000; i++)
    {
        shared_ptr<int> temp = global_instance;
    }

    // This is not thread-safe.  While all the threads are the same, the
    // "final" value of this is almost certainly NOT going to be
    // number_of_threads*10000 = 100,000.  It'll be something else.
    for(int i = 0; i < 10000; i++)
    {
        *global_instance = *global_instance + 1;
    }
}

 

用std::thread和join体验以下多线程吧：

a) 两个线程交替打印，执行了std::thread的定义之后，线程就开始运行了，并不是等到join函数执行的时候才开始运行哦！join函数的作用仅仅是让主线程等待其他线程的结束。

#include <thread>
#include <mutex>
#include <iostream>

void thread_3()
{
	for (int i = 0; i < 100; i++) {
		std::cout << "Thread 3\n";
	}
}
void thread_4()
{
	for (int i = 0; i < 100; i++) {
		std::cout << "Thread 4\n";
	}
}

int main()
{
	
	//交替打印3 4 
	thread threadG(thread_3);
	thread threadH(thread_4);

	threadG.join();
	threadH.join();
}

 

b）不加锁时，不能得到准确的累加结果。 

启动了 6个线程对一个全局变量进行累加，不加锁的话，不能得到正确的最终结果：10*10000*6.

加锁的话可以用mutex锁，也可以用c++ 的automic原子类型( https://blog.csdn.net/qq_35865125/article/details/105611985 )。

#include <thread>
#include <mutex>
#include <iostream>
void thread_2()
{
	for (int i = 0; i < 10*10000; i++) {
		//std::lock_guard<mutex> lockGuard(g_mutex);//加锁才能保证最后结果的正确
		g_var++;
	}
	std::cout << "Thread 2 finished. \n";
}


int g_var=0;
int main()
{
    std::cout << "Hello World!\n"; 


	thread threadA(thread_2);
	thread threadB(thread_2);
	thread threadC(thread_2);
	thread threadD(thread_2);
	thread threadE(thread_2);
	thread threadF(thread_2);

	threadA.join();
	threadB.join();
	threadC.join();
	threadD.join();
	threadE.join();
	threadF.join();
//将g_var用shared_ptr进行托管，也不能解决问题。需要加锁
	cout << "g_var= " << g_var << endl<<endl; 
	
	
	
}

 

 

---

May <C++ Concurrency in Action 2nd Edition> will give an ansower!

 

---

https://www.cnblogs.com/gqtcgq/p/7492772.html 对boost的shared_ptr线程安全的讲解。

该作者的下面这段介绍，非常清晰地总结了shared_ptr的基本原理，向别人讲解时，非常适用！：

shared_ptr 是引用计数型（reference counting）智能指针，几乎所有的实现都采用在堆（heap）上放个计数值（count）的办法（除此之外理论上还有用循环链表的办法，不过没有实例）。

具体来说，shared_ptr<Foo> 包含两个成员，一个是指向 Foo 的指针 ptr，另一个是 ref_count 指针（其类型不一定是原始指针，有可能是 class 类型，但不影响这里的讨论），指向堆上的 ref_count 对象。ref_count 对象有多个成员，具体的数据结构如图 1 所示，其中 deleter 和 allocator 是可选的。

 

 

 

---

Ref:

https://blog.csdn.net/jiangfuqiang/article/details/8292906

 

 

https://blog.csdn.net/weixin_41966991/article/details/81071507