C++并发编程 thread(转)
std::thread
C++11在标准库中为多线程提供组件, 使用线程需要包含头文件 thread, 其命名空间为 std.
启动新线程
每个进程至少有一个线程: 执行main()函数的线程, 其余线程有其各自的入口函数(线程函数)。
当线程执行完线程函数后, 线程也会退出. 如果不传入线程函数(类似这种形式std::thread t;), 线程不会运行. 线程函数不能重载, 否则不能编译.
在为一个线程创建了一个 std::thread 对象后, 如果线程已启动(不传入线程序函数时, 线程不会启动), 必须要明确是加入(join)还是分离线程(detach).
// 启动一个线程:
void MyThread(const std::string& str)
{
PRINT_LINE_INFO();
std::cout << str << std::endl;
}
//std::thread t(MyThread, "Hello C...");
std::thread t([] {
MyThread("Hello C...");
MyThread("Hello C2...");
});
// 对于类方法, 需要使用 std::bind.
std::thread t(std::bind(&ThreadExample::MyThread, this, "msg"));
ThreadGuard tg(t);
如果 std::thread 对象销毁之前还没有调用 join 或 detach, 程序就会终止( std::thread 的析构函数会调用 std::terminate() ). 因此, 即便是有异常存在, 也需要确保线程能够正确的加入(joined)或分离(detached).
调用 join 或 detach 之前需要调用 joinable() 判断一下线程是否运行. 如果 joinable() 返回 false, 则不需要.
join()是简单粗暴的等待线程完成, 此时创建 std::thread 对象的线程(以下称主线程)将被阻塞. 如果在线程启动后到主线程在调用 join() 前的代码中发生了异常, 此时将会导致主线程永远没有机会执行.
针对此问题, 需要使用 RAII 机制来解决, 如创建一个 ThreadGuard 对象, 在析构函数中保证总是可以调用到 join.
#ifndef _THREAD_GUARD_
#define _THREAD_GUARD_
#include <thread>
class ThreadGuard
{
public:
ThreadGuard(std::thread& t_) : t(t_){}
~ThreadGuard()
{
if (t.joinable())
{
t.join();
}
}
ThreadGuard(const ThreadGuard &) = delete;
ThreadGuard& operator=(const ThreadGuard &) = delete;
private:
std::thread& t;
};
#endif // _THREAD_GUARD_
如果是分离线程, 必须保证可访问数据的有效性, 否则会产生未定义的行为, 如同单线程中一个对象被销毁后再访问一样.
处理这种情况的常规方法: 使线程函数的功能齐全, 将数据复制到线程中. 如果使用一个可调用的对象作为线程函数,这个对象就会复制到线程中,而后原始对象就可以销毁. 下面是错误的使用方法示例:
class Func
{
int& i;
public:
Func(int& i_) : i(i_) {}
void operator() ()
{
for (unsigned j = 0; j < 10; ++j)
{
// 潜在访问隐患:悬空引用 i
std::cout << i << " ";
}
std::cout << std::endl;
}
};
{ // 某个作用域内
int* p = new int(100);
Func f(*p);
std::thread t(f);
t.detach(); // 不等待线程结束
delete p;
} // 新线程可能还在运行
线程函数
线程函数可以有不同的参数, 向线程传递参数,只要在构造 std::thread 对象时,按照线程函数参数列表一一对应传入即可。线程函数有几点需要注意的地方:
(1) 默认的参数会被拷贝到独立的线程中,即使是引用的形式, 如果需要需要传递引用, 需要使用 std::ref 显示说明(并且线程函数参数也需要声明为引用).
void ThreadParamRef(std::string& str)
{
str += " --> add";
}
void ThreadParam(std::string str)
{
str += " --> add";
}
std::string str("Hello C++ Thread...");
//std::thread t(ThreadParamRef, str);
std::thread t(ThreadParamRef, std::ref(str)); // 只有这种形式才能在线程执行完毕后输出 Hello C++ Thread... --> add
//std::thread t(ThreadParam, std::ref(str));
t.join();
std::cout << str << std::endl;
(2) 线程参数传递时需要注意不能传入局部变量, 考虑下面的代码,buffer②是一个指针变量,指向本地变量,然后本地变量通过buffer传递到新线程中②。
函数有很大的可能,会在字面值转化成 std::string 对象之前崩溃,从而导致线程的一些未定义行为。
解决方案就是在传递到 std::thread 构造函数之前就将字面值转化为 std::string 对象。
void f(int i,std::string const& s);
void oops(int some_param)
{
char buffer[1024]; // 1
sprintf(buffer, "%i",some_param);
std::thread t(f,3,buffer); // 2
t.detach();
}
// 正确的方法
void f(int i,std::string const& s);
void not_oops(int some_param)
{
char buffer[1024];
sprintf(buffer,"%i",some_param);
std::thread t(f,3,std::string(buffer)); // 使用std::string,避免悬垂指针
t.detach();
}
(3) 线程函数参数传递时, 可以移动, 但不能拷贝. "移动"是指: 原始对象中的数据转移给另一对象,而转移的这些数据在原始对象中不再保存.
void ThreadParamUniquePtr(std::unique_ptr<int> up)
{
std::cout << (up.get() ? *up : -1) << std::endl;
}
std::thread t(ThreadParamUniquePtr, std::move(up));
//std::thread t(ThreadParamUniquePtr, up); // 不能编译
//std::thread t(ThreadParamUniquePtr, std::ref(up)); // 要求线程函数参数也为引用才能编译
t.join();
std::cout << (up.get() ? *up : -1) << std::endl; // 将输出-1
线程所有权转移
线程是资源独占型, 但可以将所有权转移给别的对象. 如果一个 std::thread 对象与一个运行的线程关联, 此时接受一个新的线程所有权时, 其以前关联的线程将直接调用 std::terminate() 终止程序继续运行.
std::thread t1(f);
std::thread t2(f);
// t1 = std::thread(f); // t1 所有权还没有转移, 不能通过赋一个新值来放弃线程
// t1 = std::move(t2); // t1 所有权还没有转移, 不能通过赋一个新值来放弃线程
t1.detach(); 或 t1.join();
t1 = std::move(t2);
std::thread t3 = std::move(t1);
t1 = std::move(t2);
线程对象也可以在函数中进行转移.
std::thread f1()
{
return std::thread(f);
}
std::thread f2()
{
std::thread t(f);
return t;
}
void f3(std::thread t);
void f4()
{
f3(std::thread(f));
std::thread t(f);
f3(std::move(t));
}
由于 std::thread 是可转移的, 如果容器对移动操作支持, 则可以将 std::thread 对象放入其中.
class Func
{
int i;
public:
Func(int i_) : i(i_) {}
void operator() ()
{
for (unsigned j = 0; j < 10; ++j)
{
std::cout << i << " ";
}
std::cout << std::endl;
}
};
std::vector<std::thread> threads;
for (int i = 1; i < 10; i++)
{
Func f(i);
//std::thread t(f);
//v.push_back(t); // 不能采用这种方式
//v.push_back(std::move(t)); // 需要使用移动操作才可以
threads.push_back(std::thread(f));
}
std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join)); // 对每个线程调用join()
常用函数
std::thread::hardware_concurrency() 返回 CPU 核心线程数. 如果无法查询系统信息时, 返回0. (static 函数)
get_id() 返回 std::thread 对象关联的线程的 id. 如果所有权已转移, 或线程函数已返回, 返回0.
std::this_thread::get_id() 取得当前线程的 id. (static 函数)
一个更好的ThreadGuard
#ifndef _THREAD_GUARD_
#define _THREAD_GUARD_
template <class _Thread>
class ThreadGuard
{
public:
explicit ThreadGuard(_Thread& t_) : t(t_) {}
~ThreadGuard()
{
if (t.joinable())
{
t.join();
}
}
ThreadGuard(const ThreadGuard &) = delete;
ThreadGuard& operator=(const ThreadGuard &) = delete;
private:
_Thread& t;
};
#endif // _THREAD_GUARD_