线程安全的对象生命周期管理

线程安全的 class 应当满足的条件

多个线程同时访问时，其表现出正确的行为
无论操作系统如何调度这些线程，无论这些线程的执行顺序如何交织
调用端代码无须额外的同步或其他协调动作

对象创建的线程安全

对象创建要做到线程安全，唯一的要求就是在构造期间不要泄露 this 指针：

不要在构造函数中注册任何回调
不要在构造函数中把 this 传递给跨线程的对象

因为构造函数函数在执行期间还没有完成对象的初始化，如果 this 被泄露给其它对象(其自身创建的子对象除外)，那么别的线程有可能访问这个半成品对象。

例如下面的写法是强烈不推荐的：

class Foo
{
public:
	Foo(Observable *s)
	{
		s->register(this);
	}
};

正确的写法：

class Foo
{
public:
	Foo()
	{		
	}
	
	//@ 先构造再注册
	void observer(Observable *s)
	{
		s->register(this);
	}
};

析构函数的多线程安全问题

当一个对象被多个线程可见时，对象的销毁时机可能造成竞态条件：

析构一个对象时，如何得知此刻是否有别的线程正在执行该对象的成员函数？
在调用一个对象的成员函数之前，如何确保这个对象还存在，它的析构函数是否会碰巧执行了一半？
如何保证一个对象的成员函数执行期间，该对象不会被其他线程析构？

mutex 不是解决办法

例如：

class Test final
{
public:

	Test()
	{ 
		p_ = new int(0);

		std::cout << "ctor" << std::endl;
	}

	~Test() 
	{ 
		std::lock_guard<std::mutex> lock(m_);
		delete p_;
		p_ = nullptr;

		std::cout << "dctor" << std::endl; 
	}

	void update(int x)
	{
		std::lock_guard<std::mutex> lock(m_);
		*p_ = x;
	}

private:
	std::mutex m_;
	int* p_;
};

Test* g_test_p = new Test;


void f1()
{
	if (g_test_p != nullptr)
	{
		std::cout << "update" << std::endl;
		g_test_p->update(100);
	}
}

void f2()
{
	delete g_test_p;
	g_test_p = nullptr;
}

int main()
{
	std::thread t2(f2);
	std::thread t1(f1);

	t1.join();
	t2.join();

    return 0;
}

作为 class 数据成员的 mutex 只能用于同步本 class 的其他数据成员的读和写，不能保证安全的析构。因为 mutex 成员的生命周期最多和对象一样长，而析构动作可以说是发生在对象的身亡之时(之后)。

对于基类对象，调用到基类析构函数时，派生类对象已经析构了，那么基类对象的 mutex 就不能完整的保护整个析构过程。

析构过程本质上来说，也不应该被 mutex 保护，因为只有保证别的线程访问不到这个对象时，析构才是安全的。即要想安全地销毁对象，最好在别的线程都看不到的情况下，偷偷地做。

shared_ptr/weak_ptr 解决方案

shared_ptr 是基于引用计数的，引用计数是自动化资源管理的常用方法，当引用计数降为 0 时，对象就被销毁。weak_ptr 也是一个计数型智能指针，但是它不增加引用计数，属于弱引用。

shared_ptr 控制对象的生命周期，只要有一个指向对象的 shared_ptr 存在，该对象就不会析构，当指向对象的最后一个 shared_ptr 析构或者 reset 时候，对象保证会被销毁
weak_ptr 不控制对象的生命周期，但是它知道对象是否还存在，如果对象存在，它可以提升为有效的 shared_ptr，如果对象不存在，则提升失败，返回一个空的 shared_ptr，提升的行为是线程安全的

shared_ptr 本身的线程安全性

shared_ptr 的引用计数是安全且无锁的，但是它本身不是线程安全的，要在多个线程中同时访问同一个 shared_ptr，正确的用法是加 mutex 保护。

std::mutex g_mutex;
std::shared_ptr<Foo> g_ptr;


void do_it(const std::shared_ptr<Foo>& p){}

//@ 读取时需要加锁
void read()
{
	std::shared_ptr<Foo> local_ptr;
	{
		std::lock_guard<std::mutex> lock(g_mutex);
		local_ptr = g_ptr;
	}
	do_it(local_ptr);
}

//@ 写入时需要加锁
void write()
{
	std::shared_ptr<Foo> new_ptr(new Foo);
	{
		std::lock_guard<std::mutex> lock(g_mutex);
		g_ptr = new_ptr;
	}
	do_it(new_ptr);
}

shared_ptr 技术与陷阱

意外延长对象的生命周期

只有指向对象的 shared_ptr 有一个存在，对象就不会释放，从而在一些情况下导致对象的生命周期意外延长。

class Foo 
{
public:
	Foo() { std::cout << "ctor" << std::endl; }
	~Foo() { std::cout << "dctor" << std::endl; }

	void do_it() { std::cout << "do_it" << std::endl; }
};

int main()
{
	std::shared_ptr<Foo> pFoo(new Foo);
	auto func = std::bind(&Foo::do_it, pFoo);

	//@ do something else
	return 0;
}

传参

执行 shared_ptr 的拷贝时需要修改引用计数，这个开销要比拷贝原始指针高，多数情况下可以使用 const reference 的方式传递，一个线程只需要在最外层函数有一个实体对象，之后都可以使用 const reference 的方式传递这个对象。

void save(const std::shared_ptr<Foo>& pFoo) {}
void validate(const std::shared_ptr<Foo>& pFoo) {}

void on_message(const std::string& msg)
{
	std::shared_ptr<Foo> pFoo(new Foo(msg));
	if (validate(pFoo))  //@ 没有拷贝 pFoo
	{
		save(pFoo); //@ 没有拷贝 pFoo
	}
}

析构动作在创建时被捕获

虚析构不再是必须的
shared_ptr<void> 可以持有任何对象，而且能够安全释放
shared_ptr 对象可以安全地跨越模块边界，比如从 dll 中返回，而不会造成模块 A 分配的内存在模块 B 中释放的情况
二进制兼容性，即便 shared_ptr 指向的对象大小改变了，那么旧的客户代码仍然可以使用新的库，而无须重新编译
析构动作可以定制

虚析构不是必须的

class Base
{
public:
	~Base() { std::cout << "base dctor" << std::endl; }
};

class Derived : public Base
{
public:
	~Derived() { std::cout << "derived dctor" << std::endl; }
};

int main()
{
	//@ 使用智能指针可以正确释放
	{
		std::shared_ptr<Base> p1(new Derived);
	}
	std::cout << "-------------------------------------" << std::endl;

	//@ 普通指针，当基类的析构函数不是虚函数时，子类的析构函数不会被调用
	Base* p2 = new Derived;
	delete p2;
}

`shared_ptr<void>` 可以持有任何对象

class Foo
{
public:
	Foo()
	{
		std::cout << "Foo ctor" << std::endl;
	}

	~Foo()
	{
		std::cout << "Foo dctor" << std::endl;
	}

private:
	int * p;
};

int main(int argc, const char** argv)
{
	//@ 并不会调用 Foo 的析构函数，导致资源泄露
	{
		void * p1 = new Foo;
		delete p1;
	}
	std::cout << "---------------------------------" << std::endl;

	//@ 会调用 Foo 的析构函数
	{
		std::shared_ptr<void> p3 = std::shared_ptr<Foo>(new Foo);
	}
}

析构所在的线程

对象的析构是同步的，当最后一个指向对象的 shared_ptr 离开其作用域的时候，对象就会在同一个线程析构，这个线程不一定是对象诞生的线程，如果对象的析构十分耗时，那么可能会拖慢关键线程的速度，可以使用一个单独的线程专门处理析构，通过一个 BlockingQueue<shared_ptr<void>> 把对象的析构转移到专门的线程。

定制析构函数

假设：

class Stock final
{
public:
	explicit Stock(const std::string& key) :key_(key) {}
	std::string key() const {
		return key_;
	}
private:
	std::string key_;
};

class StockFactory
{
public:
	std::shared_ptr<Stock> get(const std::string& key) {
		std::lock_guard<std::mutex> lock(mtx_);
		if (stocks_.find(key) == stocks_.end()) {
			stocks_[key] = std::make_shared<Stock>(key);
		}
		return stocks_[key];
	}

private:
	mutable std::mutex mtx_;
	std::map<std::string, std::shared_ptr<Stock>> stocks_;
};

这种写法导致的结果就是 map 中存放的 shared_ptr 一直不会被释放，Stock 对象不会被销毁。

修改为：

class Stock final
{
public:
	explicit Stock(const std::string& key) :key_(key) {}
	std::string key() const {
		return key_;
	}
private:
	std::string key_;
};


class StockFactory
{
public:
	std::shared_ptr<Stock> get(const std::string& key) {
		std::shared_ptr<Stock> pStock;
		std::lock_guard<std::mutex> lock(mtx_);
		auto& wkStock = stocks_[key]; //@ 引用
		pStock = wkStock.lock(); //@ 提升
		if (!pStock) {
			pStock.reset(new Stock(key));
			wkStock = pStock; //@ 更新 map
		}
		return pStock;
	}

private:
	mutable std::mutex mtx_;
	std::map<std::string, std::weak_ptr<Stock>> stocks_;
};

这样 Stock 对象会被销毁，但是 map 的大小只增不减。

终极的解决办法是定制 shared_ptr 的删除函数：

class Stock final
{
public:
	explicit Stock(const std::string& key) :key_(key) {}
	std::string key() const {
		return key_;
	}
private:
	std::string key_;
};

class StockFactory
{
public:
	std::shared_ptr<Stock> get(const std::string& key) {
		std::shared_ptr<Stock> pStock;
		std::lock_guard<std::mutex> lock(mtx_);
		auto& wkStock = stocks_[key];  //@ 引用
		pStock = wkStock.lock(); //@ 提升
		if (!pStock) {
			using std::placeholders::_1;
			pStock.reset(new Stock(key),std::bind(&StockFactory::delete_stock,this,_1));
			wkStock = pStock; //@ 更新 map
		}	
		return pStock;
	}

private:
	void delete_stock(Stock* stock) {
		if (stock)
		{
			std::lock_guard<std::mutex> lock(mtx_);
			stocks_.erase(stock->key());
		}

		delete stock;
	}
private:
	mutable std::mutex mtx_;
	std::map<std::string, std::weak_ptr<Stock>> stocks_;
};

但是这里将 StockFactory 的 this 指针传递给了 bind，如果 StockFactory 先于 Stock 对象析构，那么当 Stock 析构的时候将会发生错误。

enable_shared_from_this

继承自 enable_shared_from_this 的类，可以将 this 指针变成 shared_ptr：

class Stock final
{
public:
	explicit Stock(const std::string& key) :key_(key) {}
	std::string key() const {
		return key_;
	}
private:
	std::string key_;
};

class StockFactory  : public std::enable_shared_from_this<StockFactory>
{
public:
	std::shared_ptr<Stock> get(const std::string& key) {
		std::shared_ptr<Stock> pStock;
		std::lock_guard<std::mutex> lock(mtx_);
		auto& wkStock = stocks_[key];  //@ 引用
		pStock = wkStock.lock(); //@ 提升
		if (!pStock) {
			using std::placeholders::_1;
			pStock.reset(new Stock(key), std::bind(&StockFactory::delete_stock, shared_from_this(), _1)); //@ 更新成 shared_from_this
			wkStock = pStock; //@ 更新 map
		}
		return pStock;
	}

private:
	void delete_stock(Stock* stock) {
		if (stock)
		{
			std::lock_guard<std::mutex> lock(mtx_);
			stocks_.erase(stock->key());
		}

		delete stock;
	}
private:
	mutable std::mutex mtx_;
	std::map<std::string, std::weak_ptr<Stock>> stocks_;
};

为了使用 shared_from_this，StockFactory 不能是栈上对象，必须是堆上对象，并且由 shared_ptr 管理其生命周期：

//@ OK
{
    std::shared_ptr<StockFactory> sf = std::shared_ptr<StockFactory>(new StockFactory);
    sf->get("zgpn");
}

//@ Error
{
    StockFactory* sf = new StockFactory;
    sf->get("zgpn");
}

//@ Error
{
    StockFactory sf;
    sf.get("zgpn");
}

另外需要注意的是，shared_from_this 不能在构造函数中调用，因为在构造过程中对象还没有交给 shared_ptr 接管。

另外，一点就是 StockFactory 的生命周期似乎被意外延长了。shared_ptr 绑定到函数对象之后，那么回调的时候 StockFactory 对象始终存在，是安全的。但同时也使得 StockFactory 的生命周期不会短于函数对象。

弱回调

如果希望实现对象活着就调用对象，否则忽略之，这种方式称为 "弱回调"。这个技术的关键就是使用 weak_ptr：

class Stock final
{
public:
	explicit Stock(const std::string& key) :key_(key) {}
	std::string key() const {
		return key_;
	}
private:
	std::string key_;
};

class StockFactory  :  public std::enable_shared_from_this<StockFactory>
{
public:
	std::shared_ptr<Stock> get(const std::string& key) {
		std::shared_ptr<Stock> pStock;
		std::lock_guard<std::mutex> lock(mtx_);
		auto& wkStock = stocks_[key];
		pStock = wkStock.lock(); //@ 提升
		if (!pStock) {
			using std::placeholders::_1;
			pStock.reset(new Stock(key), std::bind(&StockFactory::weak_delete_callback, std::weak_ptr<StockFactory>(shared_from_this()), _1)); //@ 更新成 shared_from_this
			wkStock = pStock; //@ 更新 map
		}
		return pStock;
	}

private:
	static void weak_delete_callback(const std::weak_ptr<StockFactory>& wkFactory,Stock* stock) 
	{
		std::shared_ptr<StockFactory> pFactory = wkFactory.lock();
		if (pFactory)
			pFactory->remove_stock(stock);

		delete stock;
	}

	void remove_stock(Stock* stock) 
	{
		if (stock)
		{
			std::lock_guard<std::mutex> lock(mtx_);
			stocks_.erase(stock->key());
		}
	}
private:
	mutable std::mutex mtx_;
	std::map<std::string, std::weak_ptr<Stock>> stocks_;
};

void test_long_life_factory()
{
	std::shared_ptr<StockFactory> factory(new StockFactory);
	{
		std::shared_ptr<Stock> stock1 = factory->get("IBM");
		std::shared_ptr<Stock> stock2 = factory->get("IBM");
		assert(stock1 == stock2);
	}
}

void test_short_life_factory()
{
	std::shared_ptr<Stock> stock1;
	{
		std::shared_ptr<StockFactory> factory(new StockFactory);
		stock1 = factory->get("IBM");
		std::shared_ptr<Stock> stock2 = factory->get("IBM");
		assert(stock1 == stock2);
	}
}



int main()
{
	test_long_life_factory();

	test_short_life_factory();

	return 0;
}

由此，无论 Stock 和 StockFactory 谁先挂掉，都不会影响程序的正常运行。

__EOF__

本文作者：刘皇叔
本文链接：https://www.cnblogs.com/xiaojianliu/p/16131421.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2022-04-11 18:42 刘-皇叔阅读(279) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· pytorch 深度学习之微积分

· pytorch 深度学习之数据操作

· 《Linux多线程服务端编程》笔记

· 线程安全的对象生命期管理

· UIUC CS241 讲义：众包系统编程书

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 如何调用 DeepSeek 的自然语言处理 API 接口并集成到在线客服系统
· 【译】Visual Studio 中新的强大生产力特性
· 2025年我用 Compose 写了一个 Todo App

公告

线程安全的对象生命周期管理

发表于 2022-04-11 18:42阅读：279评论：0推荐：0

C++

WeChat

关注

跳至底部

昵称：刘-皇叔
园龄： 7年10个月
粉丝： 110
关注： 0

+加关注

刘皇叔

接着奏乐，接着舞！

线程安全的对象生命周期管理

线程安全的 class 应当满足的条件

对象创建的线程安全

析构函数的多线程安全问题

mutex 不是解决办法

shared_ptr/weak_ptr 解决方案

shared_ptr 本身的线程安全性

shared_ptr 技术与陷阱

意外延长对象的生命周期

传参

析构动作在创建时被捕获

虚析构不是必须的

`shared_ptr<void>` 可以持有任何对象

定制析构函数

enable_shared_from_this

弱回调

公告

刘皇叔

线程安全的对象生命周期管理

搜索

常用链接

最新随笔

积分与排名

随笔分类 (62)

随笔档案 (85)

文章分类 (501)

文章档案 (512)

相册 (1)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

刘皇叔

接着奏乐，接着舞！

线程安全的对象生命周期管理

线程安全的 class 应当满足的条件

对象创建的线程安全

析构函数的多线程安全问题

mutex 不是解决办法

shared_ptr/weak_ptr 解决方案

shared_ptr 本身的线程安全性

shared_ptr 技术与陷阱

意外延长对象的生命周期

传参

析构动作在创建时被捕获

虚析构不是必须的

shared_ptr<void> 可以持有任何对象

定制析构函数

enable_shared_from_this

弱回调

公告

刘皇叔

线程安全的对象生命周期管理

搜索

常用链接

最新随笔

积分与排名

随笔分类 (62)

随笔档案 (85)

文章分类 (501)

文章档案 (512)

相册 (1)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

`shared_ptr<void>` 可以持有任何对象