1. 启动线程
在C++ 11中线程是在std::thread对象创建时启动。因为我们把启动线程的重心放在如何构造这个thread对象,其构造函数有以下几个:
//仅仅是构造一个线程类,但没有和具体化的线程函数关联
thread() noexcept;
// 移动构造函数
thread( thread&& other ) noexcept;
//构造新的 std::thread 对象并将它与执行线程关联
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
其中f是任意一个可调用对象,包括普通函数、函数对象 、lambda表达式等,args是传递给线程函数的参数。
需要特别注意的是,传到线程函数的参数默认是按值传递或者被移动的,若需要传递引用参数给线程函数,则必须包装它(例如用 std::ref 或 std::cref )。
启动线程的核心代码:
//代码清单 1
//函数对象
class background_task
{
public:
background_task(int number, char* pszName) :
m_nNumber(number),
m_pszName(pszName){}
~background_task(){}
void operator()() const
{
std::this_thread::sleep_for(std::chrono::seconds(2));
//分离式情况下,m_pszName是非法指针
std::cout << "number is: " << m_nNumber << " name is: " << m_pszName << std::endl;
}
private:
int m_nNumber;
std::string m_strName;
char* m_pszName;
};
// t1 非线程
std::thread t1;
//使用普通函数进行构造线程,按值传递
void f1(int n){std::cout << n << std::endl;}
std::thread t2(f1, 10);
//使用函数对象构造线程,使用引用
background_task task(12, "jimmy");
std::thread run_task(std::ref(task));
2.等待线程完成或者分离
当我们启动了一个线程,我们需要明确是要等待线程结束(加入式),还是让其自主运行(分离式)。即线程对象退出之前必须明确调用join或detach,否则会崩溃。需要注意的是,必须在std::thread对象销毁之前做出决定,否则你的程序将会终止(std::thread的析构函数会调用std::terminate(),这时再去决定会触发相应异常)。如下代码,既没调用
join又没detach,程序崩溃:
#include <memory>
#include <string>
#include <iostream>
#include <thread>
//代码清单 1
//函数对象
class background_task
{
public:
background_task(int number, char* pszName) :
m_nNumber(number),
m_pszName(pszName) {}
~background_task() {}
void operator()() const
{
std::this_thread::sleep_for(std::chrono::seconds(2));
//分离式情况下,m_pszName是非法指针
std::cout << "number is: " << m_nNumber << " name is: " << m_pszName << std::endl;
}
private:
int m_nNumber;
std::string m_strName;
char* m_pszName;
};
//使用普通函数进行构造线程,按值传递
void f1(int n) { std::cout << n << std::endl; }
int main()
{
// t1 非线程
std::thread t1;
std::thread t2(f1, 10);
{
//使用函数对象构造线程,使用引用
/*char* p = const_cast<char*>("jimmy");*/
char p[] = "jimmy";
background_task task(12, p);
/*std::thread run_task(std::ref(task));*/
std::thread run_task(std::ref(task));
}
getchar();
return 0;
}
如果线程是加入式的,我们需要调用std::thread的类成员函数join(),等待线程结束,然后在执行join()之后的代码。
如果不等待线程,我们需要调用std::thread的类成员函数detach(),此时就必须保证线程结束之前,可访问的数据得有效性。否则会产生未定义行为,或者不符号预期的值产生。这个是因为线程函数还持有函数局部变量的指针或者引用。
//代码清单 2
//危险代码示例
int _tmain(int argc, _TCHAR* argv[])
{
{
std::cout << "enter local zone..." << std::endl;
char *buffer = new char[128];
sprintf(buffer, "%s", "this is thread...\n");
//传入指针,在函数对象中引用了指针
background_task task(12, buffer);
std::thread run_task(std::ref(task));
//加入式,此时等到线程结束,指针一直有效
//run_task.join();
//分离式,主线程不等创建的新线程,指针提前释放,存在非法行为
run_task.detach();
//释放指针
delete[] buffer;
buffer = NULL;
std::cout << "leave local zone..." << std::endl;
}
std::this_thread::sleep_for(std::chrono::seconds(5));
}
运行结果:
加入式运行结果符合预期,分离式引用了非法内存值,结果异常,更严重时会因此崩溃形为。
3.后台运行线程
当我们调用std::thread成员函数detach()后,会让执行线程在后台运行,此时主线程不能与之产生直接交互,并且不会等待这个线程执行结束,此时相关thread对象就无法被加入。
不过C++运行库保证,当线程退出时,相关资源的能够正确回收,后台线程的归属和控制C++运行库都会处理。
background_task task(12, buffer);
std::thread run_task(std::ref(task));
run_task.detach();
//在清单2中增加get_id()以及joinalbe()测试接口
std::cout << "detach thread id : " << run_task.get_id() << std::endl;
std::cout << "detach thread joinable status: " << run_task.joinable() << std::endl;
执行结果:
detach thread id : 0
detach thread joinable status: 0
当我调用detach()成员函数之后,相应的std::thread对象就与实际执行的线程无关了,就不能再调用join()成员函数,否则会抛异常。同时线程ID值也被设置成为0.
如下代码:
int main()
{
// t1 非线程
std::thread t1;
std::thread t2(f1, 10);
{
//使用函数对象构造线程,使用引用
/*char* p = const_cast<char*>("jimmy");*/
char p[] = "jimmy";
background_task task(12, p);
/*std::thread run_task(std::ref(task));*/
std::thread run_task(std::ref(task));
run_task.detach();
}
getchar();
return 0;
}
run_task出了大括号后被析构,但线程的执行函数对象不会因为对象被析构而崩溃、不执行
如果我们应用程序必须等待某个线程,我们则需要细心挑选调用join()的位置。当在线程运行之后产生异常,在join()调用之前抛出或者返回,就意味着这次join()调用会被跳过,为了避免产生没有调用join的情况,我们需要在可能的函数返回地方都加上join等待。
例如
int _tmain(int argc, _TCHAR* argv[])
{
background_task task(12, "this is testing cpp");
std::thread run_task(std::ref(task));
try
{
do_other_something();
}
catch (...)
{
run_task.join();
return 1;
}
if (!check_user_intput())
{
run_task.join();
return 1;
}
if (!process_user_data())
{
run_task.join();
return 1;
}
run_task.join();
return 0;
}
使用这种方式,虽然可以解决问题,但这种编码方式是不可靠或者不简洁的,如果后续新增代码,异常处忘记添加join()等待就直接返回,则隐藏了bug,不利于后续问题定位。
我们希望无论正常与否,可以提供一个简洁的机制,确保程序返回前都可以保障调用join(), 这种方式就叫RAII(资源获取即初始化方式,Resource Acquisition Is Initialization).我们在提供一个类,在析构函数中使用join().
//线程类的RAII
class thread_guard
{
public:
explicit thread_guard(std::thread& t_) :
t(t_){}
~thread_guard()
{
if (t.joinable()) // 1 这个线程可以加入
{
t.join(); // 2等待线程结束
std::cout << "thread is end..." << std::endl;
}
}
thread_guard(thread_guard const&) = delete; // 3
thread_guard& operator=(thread_guard const&) = delete;
private:
std::thread& t;
};
//test code
int _tmain(int argc, _TCHAR* argv[])
{
background_task task(12, "this is testing cpp");
std::thread run_task(std::ref(task));
//thread_guard 对象析构后 会检查run_task对象的是否可以加入,
//如果可以加入则等待线程结束在析构自身,确保线程本身以简洁的方式结束
thread_guard guard(run_task);
try
{
do_other_something();
}
catch (...)
{
return 1;
}
if (!check_user_intput())
{
return 1;
}
if (!process_user_data())
{
return 1;
}
return 0;
}
在thread_guard的析构函数的测试中,首先判断线程是否已加入①,如果没有会调用join()②进行加入。这很重要,因为join()只能对给定的对象调用一次,所以对给已加入的线程再次进行加入操作时,将会导致错误。thread_guard保障线程无论如何都会等待线程结束。