c++11-14-17_内存管理（RAII）_多线程
文章目录
- 前言：
- 什么是RAII？
-
- 指针/智能指针：
-
- 使用智能指针管理内存资源：
- `unique_ptr`的使用：
-
- 自定义删除器：
- `shared_ptr`的使用：
-
- `shared_ptr`指向同一个对象的不同成员：
- 自定义删除函数：
- 循环引用的问题：
- `weak_ptr`引入解决循环引用的问题：
- 指针作为函数参数传递：
- 利用栈特性自动释放锁：
-
- 手动实现`RAII`管理`mutex`资源：
- C++11中`RAII`管理互斥资源 `lock_guard` ：
- c++11的`unique_lock`独占式锁包装器：
- C++14的`shared_lock`共享锁包装器：
- C++17的`scoped_lock`免死锁`RAII`封装器：
- 重载`new`和`delete`运算符：
-
- 为何要重载`new`和`delete`？
- 重载全局`new`和`delete`运算符：
- 重载类成员`new`和`delete`运算符：
- 分配器：
-
- `allocator`：
- 自定义分配器：
- 未初始化内存算法：
- 限制栈中创建对象， 限制调用 delete 销毁对象 ：
- c++多线程从原理到线程池实现：
-
- 多线程概用途：
- c++11多线程基础：
-
- 线程等待与分离：
- `thread`的参数传递：
- 线程入口函数：
-
- 普通函数：
- 类成员函数：
- lambda表达式：
- `call_once`多线程调用时仅调用一次：
- 多线程通信和同步：
-
- 线程状态说明：
- 竞争状态和临界区：
- 互斥体和锁：
-
- `try_lock(std::mutex)`尝试加锁：
- `try_lock_for(std::timed_mutex)`超时锁：
- 递归锁（可重入锁）`recursive_mutex` 和`recursive_timed_mutex` 用于业务组合：
- 共享锁shared_mutex：
- 利用栈自动释放锁：
- 条件变量：
- 不同线程通信方式实现线程池：
-
- 基于互斥锁和`sleep`实现：
- 基于条件变量实现：
- 智能指针管理和异步获取结果的实现：
- lambda表达式的实现原理：
- c++11中call_once函数的使用：
前言：
- c++程序大部分的问题，都是内存调试的问题。
- c++新特性中，智能指针和内存池使用时，如果使用不熟练也会存在很大问题。
什么是RAII？
RAII（Resource Acquisition is Initialization）资源获取即初始化，即构造函数中申请分配资源，在析构函数中释放资源。因为C++的语言机制保证了，当一个对象创建时自动调用构造函数，当对象超出作用域时会自动调用析构函数。所以在RAII的指导下，我们应该使用类来管理资源并将资源和对象的生命周期绑定，从而可将局部类对象生命周期交由操作系统来管理无需人工介入，避免了忘记释放资源而导致的死锁或内存泄露。
指针/智能指针：
使用智能指针管理内存资源：
智能指针（std::shared_ptr、std::unique_ptr）即RAII最具代表的实现，使用智能指针可以实现自动的内存管理，再也不需要担心忘记delete造成的内存泄漏。毫不夸张的讲，有了智能指针，代码中几乎不需要再出现delete了。
unique_ptr的使用：
独占所有权并在unique_ptr离开作用域时释放该对象的智能指针。
- 管理单个对象，如以 new 分配；
- 管理动态分配的对象数组，如以 new[] 分配；
- 可移动构造
Move Constructible和移动赋值Move Assignable， 但不可拷贝构造Copy Constructible或拷贝赋值Copy Assignable。
注意：两个unique_ptr之间的需要通过move进行移动拷贝或移动复制，不建议用普通指针初始化unique_ptr避免两者中任一一个释放造成另一个非法访问。
自定义删除器：
通过函数表达式或lambda表达式释放unique_ptr指向的内存空间。
#include shared_ptr的使用：
共享所有权（即多个shared_ptr指向同一对象），并在指向的内存块的引用计数为0时，释放该内存块。
- 可拷贝构造
Copy Constructible、可拷贝赋值Copy Assignable； - 数据访问非线程安全；
- shared_ptr 的控制块是线程安全，即引用计数是线程安全的；
shared_ptr指向同一个对象的不同成员：
#include 自定义删除函数：
通过可调用对象（即函数对象、仿函数或lambda表达式）释放shared_ptr指向的内存空间。
#include 循环引用的问题：
#include weak_ptr引入解决循环引用的问题：
expired检查被引用的对象是否已删除；lock创建/管理被引用的对象的shared_ptr；
注意:：weak_ptr无法直接访问其指向的对象。要访问对象，必须先将weak_ptr转换为shared_ptr。
#include 指针作为函数参数传递：
-
传递输入内存，需要提供内存大小，并设置为
const；#includeusing namespace std; void func1(const char* data, size_t size) { cout << size << "," << sizeof(data) << endl; } void func2(const char data[]) { cout << sizeof(data) << endl; } template <class Ty, size_t Size> void testMemArr(Ty(&data)[Size]) { cout << sizeof(data) << endl; } int main() { char data[] = "hello"; func1(data, sizeof(data)); func2(data); testMemArr(data); return 0; } -
传递输出内存，也需要提供内存大小作为返回值，防止内存溢出。
#includeusing namespace std; // 返回值：函数内部给其指向的内存空间分配的堆空间的大小 size_t func(char** data) { int size = 1024; *data = new char[size]; return size; } int main() { char* data = nullptr; cout << func(&data) << endl; delete data; data = nullptr; return 0; } -
unique_ptr作为参数和返回值：特别关注作为返回值时，会调用移动构造函数。#include#include using namespace std; unique_ptr<int> func(unique_ptr<int> data) { cout << *data <<endl; unique_ptr<int> data_(new int(10)); // 这里编译器会进行优化，如果返回值支持move则编译器会自动调用move进行移动拷贝构造，否则调用拷贝构造。 return data_; } int main() { unique_ptr<int> data1(new int(12)); auto data2 = func(std::move(data1)); cout << *data2 << endl; return 0; } -
shared_ptr作为参数和返回值：特别关注作为返回值时，会调用移动构造函数。#include#include using namespace std; shared_ptr<int> func(shared_ptr<int> data) { cout << *data <<endl; shared_ptr<int> data_(new int(10)); // 这里编译器会进行优化，如果返回值支持move则编译器会自动调用move进行移动拷贝构造，否则调用拷贝构造。 return data_; } int main() { shared_ptr<int> data1(new int(12)); //auto data2 = func(std::move(data1)); auto data2 = func(data1); cout << *data2 << endl; cout << data1.use_count() << ", " << data2.use_count() << endl; return 0; }
利用栈特性自动释放锁：
手动实现RAII管理mutex资源：
class XMutex
{
public:
XMutex(mutex& mtx) : mtx_(mtx)
{
cout << "Lock" << endl;
mtx_.lock();
}
~XMutex()
{
cout << "UnLock" << endl;
mtx_.unlock();
}
private:
std::mutex& mtx_;
};
static std::mutex mtx;
void TestMtx()
{
// 这里通过XMutex的局部类对象，可实现自动的释放锁，即RAII的思想（局部对象来管理资源，同时局部对象的生命周期由操作系统管理）
XMutex lock(mtx);
// ...
}
C++11中RAII管理互斥资源 lock_guard ：
C++11的lock_guard 实现，基于作用域的互斥体所有权包装器。
/* _Mutex可为：mutex互斥锁、shared_mutex共享锁、timed_mutex超时锁、recursive可重入的递归锁 */
template <class _Mutex>
class lock_guard
{
public:
using mutex_type = _Mutex;
explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) // construct and lock
{ MyMutex.lock(); }
lock_guard(_Mutex& _Mtx, adopt_lock_t) : _MyMutex(_Mtx) // construct but don't lock
{ }
~lock_guard() noexcept // destructor and unlock a mutex
{ _MyMutex.unlock(); }
// Disable copy construction and copy replication
lock_guard(const lock_guard&) = delete;
lock_guard& operator=(const lock_guard&) = delete;
}；
- 通过
{}控制锁的临界区； - C++11中，
adopt_lock类型为adopt_lock_t，假设调用方已拥有互斥的所有权；
#include c++11的unique_lock独占式锁包装器：
C++11的unique_lock实现，可移动的互斥体所有权包装器。
template<class _Mutex>
class unique_lock
{
public:
typedef _Mutex mutex_type;
// default construct
unique_lock() : _Pmtx(nullptr), _Owns(false) noexcept
{ }
// construct and lock
explicit unique_lock(_Mutex& _Mtx) : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
{
_Pmtx->lock();
}
// construct and assume already locked
unique_lock(_Mutex& _Mtx, adopt_lock_t) : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
{ }
// construct but don't lock
unique_lock(_Mutex& _Mtx, defer_lock_t) : _Pmtx(_STD addressof(_Mtx)), _Owns(false) noexcept
{ }
// construct and try to lock
unique_lock(_Mutex& _Mtx, try_to_lock_t) : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock())
{ }
// construct and lock with timeout
/*template
unique_lock(_Mutex& _Mtx, const chrono::duration<_Rep, _Period>& _Rel_time) : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock_for(_Rel_time)) */
template<class _Clock, class _Duration>
unique_lock(_Mutex& _Mtx, const chrono::time_point<_Clock, _Duration>& _Abs_time) : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock_until(_Abs_time))
{ }
// try to lock until _Abs_time
unique_lock(_Mutex& _Mtx, const xtime *_Abs_time) : _Pmtx(_STD addressof(_Mtx)), _Owns(false)
{
_Owns = _Pmtx->try_lock_until(_Abs_time);
}
unique_lock(unique_lock&& _Other) : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) noexcept
{
_Other._Pmtx = nullptr;
_Other._Owns = false;
}
unique_lock& operator=(unique_lock&& _Other)
{
// different, move contents
if (this != _STD addressof(_Other))
{
if (_Owns)
{
_Pmtx->unlock();
}
_Pmtx = _Other._Pmtx;
_Owns = _Other._Owns;
_Other._Pmtx = nullptr;
_Other._Owns = false;
}
return (*this);
}
// clean up
~unique_lock() noexcept
{
if (_Owns)
{
_Pmtx->unlock();
}
}
// Disable Copy construction and Copy assignment
unique_lock(const unique_lock&) = delete;
unique_lock& operator=(const unique_lock&) = delete;
// lock the mutex
void lock()
{
_Validate();
_Pmtx->lock();
_Owns = true;
}
// try to unlock the mutex
void unlock()
{
if (!_Pmtx || !_Owns)
{
_THROW(system_error(_STD make_error_code(errc::operation_not_permitted)));
}
_Pmtx->unlock();
_Owns = false;
}
// try to lock the mutex
_NODISCARD bool try_lock()
{
_Validate();
_Owns = _Pmtx->try_lock();
return (_Owns);
}
// try to lock mutex for _Rel_time
template<class _Rep, class _Period>
_NODISCARD bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time)
{
_Validate();
_Owns = _Pmtx->try_lock_for(_Rel_time);
return (_Owns);
}
/*// try to lock mutex until _Abs_time
template
_NODISCARD bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time)*/
// try to lock the mutex until _Abs_time
_NODISCARD bool try_lock_until(const xtime *_Abs_time)
{
_Validate();
_Owns = _Pmtx->try_lock_until(_Abs_time);
return (_Owns);
}
// swap with _Other
void swap(unique_lock& _Other) noexcept
{
_STD swap(_Pmtx, _Other._Pmtx);
_STD swap(_Owns, _Other._Owns);
}
// disconnect
_Mutex* release() noexcept
{
_Mutex *_Res = _Pmtx;
_Pmtx = nullptr;
_Owns = false;
return (_Res);
}
// return true if this object owns the lock
/*_NODISCARD bool owns_lock() const noexcept*/
explicit operator bool() const noexcept
{
return (_Owns);
}
// return pointer to managed mutex
_NODISCARD _Mutex *mutex() const noexcept
{
return (_Pmtx);
}
private:
_Mutex* _Pmtx;
bool _Owns;
// check if the mutex can be locked
void _Validate() const
{
if (!_Pmtx)
{
_THROW(system_error(_STD make_error_code(errc::operation_not_permitted)));
}
if (_Owns)
{
_THROW(system_error(_STD make_error_code(errc::resource_deadlock_would_occur)));
}
}
};
-
支持临时释放锁
unlock； -
支持
adopt_lock（已拥有锁，不加锁，出栈区会释放）；{ mtx.lock(); // ... // 已拥有锁，不加锁，出栈区解锁 unique_lock<mutex> lock(mtx, adopt_lock); // ... } -
支持
defer_lock（延后加锁，不拥有，出栈区不释放）；{ // 延迟加锁，不拥有锁，出栈区不释放 unique_lock<mutex> lock(mtx, defer_lock); // ... // 加锁，退出栈区解锁 lock.lock(); } -
支持
try_to_lock尝试获得互斥的所有权而不阻塞 ，获取失败退出栈区不会释放；通过
owns_lock()函数判断，是否加锁成功；staticmutex mtx; { // ... // 尝试加锁，不阻塞，失败不拥有锁 unique_lock<mutex> lock(mtx, try_to_lock); if (lock.owns_lock()) { cout << "owns lock" << endl; } else { cout << "not owns lock" << endl; } // ... } -
支持超时参数，超时不拥有锁；
C++14的shared_lock共享锁包装器：
C++14的shared_lock实现，可移动的“共享”互斥体所有权封装器。
template<class _Mutex> // shareable lock <==> std:shared_mutex
class shared_lock
{
public:
typedef _Mutex mutex_type;
// default construct
shared_lock() : _Pmtx(nullptr), _Owns(false) noexcept
{ }
// construct with mutex and lock shared
explicit shared_lock(mutex_type& _Mtx) : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
{
_Mtx.lock_shared();
}
// construct with unlocked mutex
shared_lock(mutex_type& _Mtx, defer_lock_t) : _Pmtx(_STD addressof(_Mtx)), _Owns(false) noexcept
{ }
// construct with mutex and try to lock shared
shared_lock(mutex_type& _Mtx, try_to_lock_t) : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared())
{ }
// construct with mutex and adopt ownership
shared_lock(mutex_type& _Mtx, adopt_lock_t) : _Pmtx(_STD addressof(_Mtx)), _Owns(true)
{ }
/*// construct with mutex and try to lock for relative time
template
shared_lock(mutex_type& _Mtx, const chrono::duration<_Rep, _Period>& _Rel_time) : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_for(_Rel_time))*/
// construct with mutex and try to lock until absolute time
template<class _Clock, class _Duration>
shared_lock(mutex_type& _Mtx, const chrono::time_point<_Clock, _Duration>& _Abs_time) : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_until(_Abs_time))
{ }
// destroy the lock
~shared_lock() noexcept
{
if (_Owns)
{
_Pmtx->unlock_shared();
}
}
// construct by moving _Other
shared_lock(shared_lock&& _Other) : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) noexcept
{
_Other._Pmtx = nullptr;
_Other._Owns = false;
}
// copy by moving _Right
shared_lock& operator=(shared_lock&& _Right) noexcept
{
if (_Owns)
{
_Pmtx->unlock_shared();
}
_Pmtx = _Right._Pmtx;
_Owns = _Right._Owns;
_Right._Pmtx = nullptr;
_Right._Owns = false;
return (*this);
}
// Disable Copy construct and Copy
shared_lock(const shared_lock&) = delete;
shared_lock& operator=(const shared_lock&) = delete;
// lock the mutex
void lock()
{
_Validate();
_Pmtx->lock_shared();
_Owns = true;
}
// try to lock the mutex
_NODISCARD bool try_lock()
{
_Validate();
_Owns = _Pmtx->try_lock_shared();
return (_Owns);
}
/*// try to lock the mutex for _Rel_time
template
_NODISCARD bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time)*/
// try to lock the mutex until _Abs_time
template<class _Clock, class _Duration>
_NODISCARD bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time)
{
_Validate();
_Owns = _Pmtx->try_lock_shared_for(_Rel_time);
return (_Owns);
}
void unlock()
{ // try to unlock the mutex
if (!_Pmtx || !_Owns)
{
_THROW(system_error(_STD make_error_code(errc::operation_not_permitted)));
}
_Pmtx->unlock_shared();
_Owns = false;
}
// MUTATE
void swap(shared_lock& _Right) noexcept
{ // swap with _Right
_STD swap(_Pmtx, _Right._Pmtx);
_STD swap(_Owns, _Right._Owns);
}
// release the mutex
mutex_type* release() noexcept
{
_Mutex *_Res = _Pmtx;
_Pmtx = nullptr;
_Owns = false;
return (_Res);
}
// return true if this object owns the lock
_NODISCARD bool owns_lock() const noexcept
{
return (_Owns);
}
explicit operator bool() const noexcept
{
return (_Owns);
}
// return pointer to managed mutex
_NODISCARD mutex_type *mutex() const noexcept
{
return (_Pmtx);
}
private:
_Mutex* _Pmtx;
bool _Owns;
// check if the mutex can be locked
void _Validate() const
{
if (!_Pmtx)
{
_THROW(system_error(_STD make_error_code(errc::operation_not_permitted)));
}
if (_Owns)
{
_THROW(system_error(_STD make_error_code(errc::resource_deadlock_would_occur)));
}
}
};
// 共享锁
static shared_timed_mutex st_mtx;
{
// ...
// 读取锁，即为共享锁
{
// 调用共享锁
shared_lock<shared_timed_mutex> lock(st_mtx);
// ... read data ...
// 出栈区，释放共享锁
}
// 写入锁，即为互斥锁
{
unique_lock<shared_timed_mutex> lock(st_mtx);
// ... write data ...
}
// ...
}
C++17的scoped_lock免死锁RAII封装器：
C++17的scoped_lock实现，用于多个互斥体的免死锁 RAII 封装器，类似lock。
// class with destructor that unlocks mutexes
template<class... _Mutexes>
class scoped_lock
{
public:
// construct and lock
explicit scoped_lock(_Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...)
{
_STD lock(_Mtxes...);
}
// construct but don't lock
explicit scoped_lock(adopt_lock_t, _Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...)
{ }
// unlock all
~scoped_lock() noexcept
{
_For_each_tuple_element(_MyMutexes, [](auto& _Mutex) noexcept { _Mutex.unlock(); });
}
scoped_lock(const scoped_lock&) = delete;
scoped_lock& operator=(const scoped_lock&) = delete;
private:
tuple<_Mutexes&...> _MyMutexes;
};
// specialization for a single mutex
template<class _Mutex>
class scoped_lock<_Mutex>
{
public:
typedef _Mutex mutex_type;
// construct and lock
explicit scoped_lock(_Mutex& _Mtx) : _MyMutex(_Mtx)
{
_MyMutex.lock();
}
// construct but don't lock
explicit scoped_lock(adopt_lock_t, _Mutex& _Mtx) : _MyMutex(_Mtx)
{ }
// unlock
~scoped_lock() noexcept
{
_MyMutex.unlock();
}
scoped_lock(const scoped_lock&) = delete;
scoped_lock& operator=(const scoped_lock&) = delete;
private:
_Mutex& _MyMutex;
};
// specialization for no mutexes
template<>
class scoped_lock<>
{
public:
explicit scoped_lock()
{ /* no effects */ }
explicit scoped_lock(adopt_lock_t)
{ /* no effects */ }
~scoped_lock() noexcept
{ /* no effects */ }
scoped_lock(const scoped_lock&) = delete;
scoped_lock& operator=(const scoped_lock&) = delete;
};
死锁的情况：
#include C++17的scoped_lock实现，用于多个互斥体的免死锁 RAII 封装器，类似lock。
// c++17的scoped_lock，类似于c++11的lock，保证了锁顺序的一致，避免“死锁”
static mutex mtx1, mtx2;
// C++11 lock(...MutexType) 需要手动释放锁资源
{
lock(mtx1, mtx2);
mtx1.unlock();
mtx2.unlock();
}
// C++17 scoped_lock(...MutexType) 可实现RAII管理资源，即局部对象（局部对象由操作系统管理）来管理资源
{
scoped_lock lock(mtx1, mtx2);
}
重载new和delete运算符：
为何要重载new和delete？
- 监测内存创建销毁；
- 统计和监控泄漏；
- 内存对齐的处理；
- 特定应用：例如多进程内存共享；
重载全局new和delete运算符：
#include 重载类成员new和delete运算符：
#include 放置 placement new 和 delete,new 的空间指向已有的地址中
- 普通
new申请空间是从堆中分配空间，一些特殊的需求要在已分配的空间中创建对象，就可以使用放置placement new操作； placement new生成对象，既可以在栈上也可以在堆上；placement new生成对象销毁，要手动调用析构函数；
#include 分配器：
使用allocator将内存分配、对象构造分离开，修改空间申请到内存池。
使用过程中，可以先分配内存，对象不构造，使用时再构造。
allocator：
- 分配器用于实现容器算法时，将其与存储细节隔离从而解耦合；
- 分配器将对象的内存分配和构造分离，提供存储分配与释放的标准方法；
- STL 实现了一个标准的分配器 allocator；
#include
static void construct(Alloc& a, T* p, Args&&... args); (C++11 起 / C++20 前)
template
static void deconstruct(Alloc& a, T* p); (C++11 起 / C++20 前)
*/
// 调用构造函数
allocator_traits<decltype(xdata_allco)>::construct(xdata_allco, &dataArr[i]);
// 调用析构函数
allocator_traits<decltype(xdata_allco)>::destroy(xdata_allco, &dataArr[i]);
}
// 释放对象内存，但不调用析构
xdata_allco.deallocate(dataArr, size);
return 0;
}
自定义分配器：
- 可实现
vector数据直接到数据库、共享内存或者文件中的存取、内存泄漏探测，预分配对象存储、内存池； - 演示自定义 vector 和 list 分配器，并分析其源码；
#include 未初始化内存算法：
uninitialized_copy将范围内的对象拷贝构造到未初始化的内存区域，避免内部有堆栈空间时可能产生问题。
#include 限制栈中创建对象， 限制调用 delete 销毁对象 ：
class TestMem
{
public:
static TestMem* Create()
{
return new TestMem();
}
static void Drop(TestMem* tm)
{
delete tm;
}
private:
TestMem() { cout << "TestMem::TestMem()" << endl; }
~TestMem() { cout << "TestMem::~TestMem()" << endl; }
};
int main()
{
// 限制栈中创建对象，限制调用 delete 销毁对象
TestMem* tm = TestMem::Create();
TestMem::Drop(tm);
return 0;
}
c++多线程从原理到线程池实现：
多线程概用途：
- 任务分解：耗时操作的任务分解；
- 数据分解：充分利用多核CPU处理数据；
- 数据流分解：读写分离，解耦设计；
c++11多线程基础：
线程等待与分离：
一般如果主线程和子线程通过detach设置了分离状态，则可能主线程先退出从而导致子线程崩溃。
- 原因：主线程负责管理程序的资源，如内存分配、文件句柄等，主线程的导致这些资源的释放，从而导致子线程非法的访问而崩溃。
- 解决方方法：主线程中
join()阻塞等待子线程的结束。
thread的参数传递：
// C++11 std::thread源码
class thread
{
// .....
thread() noexcept : _Thr{} {}
template <class _Fn, class... _Args, enable_if_t<!is_same_v<_Remove_cvref_t<_Fn>, thread>, int> = 0>
explicit thread(_Fn&& _Fx, _Args&&... _Ax) {
using _Tuple = tuple<decay_t<_Fn>, decay_t<_Args>...>;
auto _Decay_copied = _STD make_unique<_Tuple>(_STD forward<_Fn>(_Fx), STD forward<_Args>(_Ax)...);
constexpr auto _Invoker_proc = _Get_invoke<_Tuple>(make_index_sequence<1 + sizeof...(_Args)>{});
Thr._Hnd = reinterpret_cast<void*>(_CSTD _beginthreadex(nullptr, 0, _Invoker_proc, Decay_copied.get(), 0, &_Thr._Id));
}
~thread() noexcept {
if (joinable()) {
STD terminate();
}
}
};
参数传递的一些坑：
- 传递空间已经销毁
- 多线程共享访问一块空间
- 传递的指针变量的生命周期小于线程
#include 线程入口函数：
普通函数：
这里就正常调用，注意传递参数的生命周期的问题就行。
类成员函数：
#include #include lambda表达式：
基本格式：[捕捉列表] (参数) mutable -> 返回值类型 {函数体}
// 线程函数为 lambda 表达式，并捕获外部变量和传递参数
int val1 = 0;
thread th([&val1](int val2) {
std::cout << "subthread begin --> " << val1 << ", " << val2 << std::endl;
}, 123);
// 线程入口为类成员 lambda 函数
class A
{
public:
void start()
{
std::thread th([&this]() {
cout << "subthread begin --> " << a << endl;
});
th.join();
}
int a;
}
call_once多线程调用时仅调用一次：
c++11标准库中，新引入的call_once函数可确保多线程环境下某个“函数”或“可调用对象”只被执行一次。
#include 多线程通信和同步：
线程状态说明：
- 初始化（Init）：该线程正在被创建。
- 就绪（Ready）：该线程在就绪列表中，等待 CPU 调度。
- 运行（Running）：该线程正在运行。
- 阻塞（Blocked）：该线程被阻塞挂起。Blocked 状态包括：pend（锁、事件、信号量等阻塞）、suspend（主动 pend）、delay（延时阻塞）、 pendtime（因为锁、事件、信号量时间等超时等待）。
- 退出（Exit）：该线程运行结束，等待父线程回收其控制块资源。
竞争状态和临界区：
竞争状态（Race Condition）：多线程同时读写共享数据；
临界区（Critical Section）：多线程同时读写共享数据的代码片段；
原则：避免竞争状态策略， 对临界区进行保护，同时只能有一个线程进入临界区。
互斥体和锁：
try_lock(std::mutex)尝试加锁：
#include lock(mtx);
//mtx.lock(); // 尝试获取锁，获取不到则阻塞等待
cout << i << "[in]" << endl;
this_thread::sleep_for(1000ms);
//mtx.unlock();
}
this_thread::sleep_for(10ms); // 这里等待10ms是为了避免该线程一直占用CPU资源，导致其他线程没有机会执行。
// 等待内核调度其他线程抢占资源。
}*/
for (;;)
{
// try_lock尝试获取锁，即显示多线程竞争锁mtx的过程
if (!mtx.try_lock())
{
cout << ".";
this_thread::sleep_for(10ms); // 这里注意try_lock有一定的开销，故一般尝试获取锁失败后，需要等一段时间才能再次获取，避免资源的无意义的消耗。
continue;
}
cout << i << "[in]" << endl;
mtx.unlock();
this_thread::sleep_for(10ms); // 这里等待10ms是为了避免该线程一直占用CPU资源，导致其他线程没有机会执行。
// 等待内核调度其他线程抢占资源。
}
}
int main(int argc, char* argv[])
{
for (int i = 0; i < 10; ++i)
{
thread th(ThreadMainMtx, i);
th.detach();
}
while (1)
{ } // 避免主线程退出，造成子线程获取全局静态锁mtx失败，而导致的程序崩溃。
return 0;
}
try_lock_for(std::timed_mutex)超时锁：
c++11超时锁通常指，在指定的时间内无法获取timed_mutex/recursive_timed_mutex锁，则放弃锁定操作，防止线程在等待锁时无限阻塞，从而影响程序的响应速度。
#include 递归锁（可重入锁）recursive_mutex 和recursive_timed_mutex 用于业务组合：
#include 共享锁shared_mutex：
在很多业务场景中，读取只能有一个线程进入，则没有充分利用 cpu 资源。共享锁可以解决这种问题，如下两种共享锁：
- c++14 共享超时互斥锁
shared_timed_mutex - c++17 共享互斥
shared_mutex
#include 利用栈自动释放锁：
详见“什么是RAII?”。
条件变量：
-
生产者-消费者模型生产者和消费者共享资源变量（list队列）；
-
生产者生产一个产品，通知消费者消费；
std::condition_variable cond; std::mutex mtx; std::list<std::string> msgs_; { unique_lock<mutex> lock(mtx); msgs_.push_back(data); lock.unlock(); cond.notify_one(); // 通知处于wait状态的一个线程 //cond.notify_all(); // 通知所有处于wait状态的线程 } -
消费者阻塞等待信号-获取信号后消费产品（取出list队列中数据）；
// wait for signal void wait(unique_lock<mutex>& _Lck) { // Nothing to do to comply with LWG‐2135 because std::mutex lock/unlock are nothrow Check_C_return(_Cnd_wait(_Mycnd(), _Lck.mutex()‐>_Mymtx())); } // wait for signal and test predicate template <class _Predicate> void wait(unique_lock<mutex>& _Lck, _Predicate _Pred) { while (!_Pred()) { wait(_Lck); } }{ unique_lock<mutex> lock(mtx); // 解锁lock，并阻塞等待 notify_one / notify_all 通知 // 接收到通知会再次获取锁，也就是说如果此时mux资源被占用，wait函数会阻塞 /*while (msgs_.empty()) { cond.wait(mtx); }*/ cond.wait(mtx, [](this)->bool { return !msgs_.empty(); }); // 处理数据 msgs_.front(); msgs_.pop_front(); std::this_thread::sleep_for(std::chrono::millseconds(10)); // 防止该线程一直占用锁读数据，导致其他线程无法获取锁 }
不同线程通信方式实现线程池：
基于互斥锁和sleep实现：
- 封装线程基类
XThread；- 控制线程启动
Start()和停止Wait()/Stop()，模拟消息服务器线程； Main()函数：接收字符串消息，并模拟处理；
- 控制线程启动
- 通过
unique_lock和mutex互斥访问list； - 消息队列主线程，定时发送消息给子线程，并通过子线程输出消息到终端屏幕上；
XThread.hpp
#include MsgServer.hpp：
#include main.cpp：
#include 基于条件变量实现：
XThread.hpp：
#include MsgServer.hpp：
#include 智能指针管理和异步获取结果的实现：
XThreadPool.hpp：
#include main.cpp：
class MyTask : public XTask
{
public:
virtual int Run() override
{
std::cout << "...................." << std::endl;
std::cout << "MyTask::Run(), " << name_ << std::endl;
while (true)
{
std::cout << std::this_thread::get_id() << " is processing." << std::endl;
if (is_exit()) // 当主线程调用Stop()后，子线程收到通知，终止执行的任务
{
break;
}
}
std::cout << "...................." << std::endl;
return 50;
}
std::string name_;
};
int main()
{
XThreadPool threadPool;
threadPool.Init(8);
threadPool.Start();
std::shared_ptr<MyTask> task1 = std::make_shared<MyTask>();
task1->name_ = "nini";
threadPool.AddTask(task1);
std::shared_ptr<MyTask> task2 = std::make_shared<MyTask>();
task2->name_ = "mimi";
threadPool.AddTask(task2);
std::shared_ptr<MyTask> task3 = std::make_shared<MyTask>();
task3->name_ = "kiki";
threadPool.AddTask(task3);
std::this_thread::sleep_for(std::chrono::microseconds(5));
std::cout << "<<<<<<<<<<" << threadPool.getTaskCount() << ">>>>>>>>>>" << std::endl;
threadPool.Stop();
std::cout << "<<<<<<<<<<" << threadPool.getTaskCount() << ">>>>>>>>>>" << std::endl;
// 异步获取子线程中的任务的执行结果（此时，子线程中任务已终止结束）
std::cout << task1->get_value() << ", " << task2->get_value() << ", " << task3->get_value() << ", " << std::endl;
return 0;
}
lambda表达式的实现原理：
c++中，lambda表达式（匿名函数）是一种方便编写的短小、简洁的函数对象的方法，编译器根据lambda表达式的捕获列表和参数、返回值，来实现一个匿名类（闭包类型）其包含了成员变量（即捕获列表中捕获的外部参数），构造函数（初始化成员变量）、重载operator()运算符（用来传入参数和返回返回值）。
int x = 0, y = 1;
auto lambda_ = [=x, &y](int z)->int {
cout << x << ", " << y << ", " << z << endl;
return 0;
;}
lambda_(2); // 调用lambda_表达式函数
/* 编译器根据lambda表达式的定义，构建出来的匿名类（闭包类型） */
class Anonymous
{
public:
Anonymous(int& x, int y) : x_(x), y_(y)
{ }
int operator()(int z)
{
cout << x << ", " << y << ", " << z << endl;
return 0;
}
private:
int& x_;
int y_;
};
Anonymous anonymous(x, y);
anonymous(2);
c++11中call_once函数的使用：
c++11标准库中，新引入的call_once函数，可确保多线程环境下某个“函数”或“可调用对象”只被执行一次。
应用场景：
-
单类模式：确保多线程同时尝试创建一个的单类的实例时，只有一个能创建成功。
#include#include class Singleton { public: Singleton* getInstance() { // 该call_once中的函数或可调用对象一旦执行过一次，initFlag的状态就会改变。 // 下次再调用时，会首先检查initFlag的状态，故不会再执行其中的函数或可调用对象。 std::call_once(initFlag, [&this]() { singleton = new Singleton(); }); return *singleton; } private: std::unique_ptr<Singleton> singleton; // std::once_flag对象是一个不可复制、不可移动的对象，但可被默认构造。 // 作用：跟踪call_once中，函数或可调用对象的是否已经被执行。 std::once_flag initFlag; Singleton() = default; Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; }; -
多线程条件下，的入口函数执行一次。