一个简单的多线程例子
#include <iostream>
#include <thread>
void foo(int i)
{
std::thread::id this_id = std::this_thread::get_id();
std::cout << "thread_func: id = " << this_id << ", " << i << std::endl;
}
int main()
{
for (uint8_t i = 0; i < 4; i++)
{
std::thread t(foo, i);
t.detach();
}
getchar();
return 0;
}
这个程序里面创建了4个线程，每次创建的时候分别传递一个标签进去，运行一次，我们可能会看到如下的输出，
thread_func: id = 139708503934720, 3
thread_func: id = 139708512327424, 2
thread_func: id = 139708520720128, 1
thread_func: id = 139708529112832, 0
可以看到这些线程的调度运行的顺序并不一定按照创建线程的先后，它有可能是任意的；
多运行几次后，我们可能会看到如下的打印
thread_func: id = thread_func: id = 140703835129600, 2
140703851915008, 0
thread_func: id = 140703843522304, 1
thread_func: id = 140703826736896, 3
显然的，第0个线程在打印的时候被第2个线程中断了，所以打印出来是这样。
那怎么解决这个问题呢，我们就引入了线程锁
引入线程锁
修改后的程序如下
#include <iostream>
#include <thread>
#include <mutex>
std::mutex g_display_mutex;
void foo(int i)
{
std::thread::id this_id = std::this_thread::get_id();
g_display_mutex.lock();
std::cout << "thread_func: id = " << this_id << ", " << i << std::endl;
g_display_mutex.unlock();
}
int main()
{
for (uint8_t i = 0; i < 4; i++)
{
std::thread t(foo, i);
t.detach();
}
getchar();
return 0;
}
这样打印消息的时候就再也不会出现中断的情况了。
detach和join
C++有两种方式来等待线程结束
- detach在这里表示启动的线程自己在后台运行，当前的代码继续运行，不等待新的线程结束
- join的方式实在线程运行完成后再继续往下运行，所以如果对之前的代码再做修改如下
int main()
{
for (int i = 0; i < 4; i++)
{
std::thread t(foo, i);
t.join();
std::cout << "main: " << i << std::endl;
}
getchar();
return 0;
}
这个时候每次main函数打印的时候都会等待新创建的线程运行完毕，所以固定的会答应如下
thread_func: id = 139945708939008, 0
main: 0
thread_func: id = 139945708939008, 1
main: 1
thread_func: id = 139945708939008, 2
main: 2
thread_func: id = 139945708939008, 3
main: 3
关于线程的异常终结
假如说以detach的方式，让线程在后台运行，那么线程的实例和线程本身就分离开了；有可能出现一种场景，
- 主函数退出了，所以维护的线程实例也会自然销毁
- 但是这个时候线程并没有运行完成，会出现异常退出的场景
处理这种问题的方法可以有两种
- 在线程实例有可能会被销毁前，调用一下join，等待线程完结；
- 或者通过类的析构函数，创建类的实例的时候创建线程实例，等到销毁这个类的时候会自动调用析构函数，在析构函数里面等待线程运行完结；
class foo
{
public:
foo();
~foo();
private:
std::thread t;
};
foo::foo()
{
t = std::thread([] {
std::thread::id this_id = std::this_thread::get_id();
std::cout << "thread: sleep for 3s! " << std::endl;
sleep(3);
g_display_mutex.lock();
std::cout << "thread id = " << this_id << std::endl;
g_display_mutex.unlock();
});
}
foo::~foo()
{
std::cout << "destructor called" << std::endl;
if (t.joinable())
{
std::cout << "joinable" << std::endl;
t.join();
}
}
int main()
{
foo m_foo;
return 0;
}
运行打印的结果如下，
destructor called
joinable
thread: sleep for 3s!
thread id = 139909607855872
- main函数创建完类的实例m_foo后就会退出函数
- main函数退出的同时需要销毁m_foo，会自动调用析构函数；
- 析构函数会等待线程t的运行完成然后再完成类foo的析构；
