【并行】std::thread入门-创新互联
参考
https://immortalqx.github.io/2021/12/04/cpp-notes-3/
对应代码
https://github.com/chunleili/learnStdThread
thread是C++11之后的一个并行STL库。由于是STL的一部分，好处是跨平台。与之相比，pthread.h只支持linux，因此建议用std::thread来代替pthread。
thread无非就是一个C++类。所以创建线程就是类的实例化，而结束则会自动调用析构函数。
thread的构造函数具有变长参数。第一个参数需要的是个函数指针/函数对象，第二个和之后的参数就是这个函数的参数。非常简单。
其中有两个成员函数最为重要：join()和detach()。
简单来说join就是主线程等待子线程的完成，而detach就是让子线程放飞自我。
hello world下面是个示例程序
#include#includeusing namespace std;
void output(int i)
{cout<< i<< endl;
}
int main()
{ for (uint8_t i = 0; i< 4; i++)
{thread t(output, i);
t.join();
}
return 0;
} 输出
0
1
2
3解释下:thread t(output, i);是创建线程。每次循环都创建一个新的线程。
t.join();然后利用join等待该线程的执行完毕。
在这里执行该线程就是打印一下i。
在这次循环完毕后，由于对象t是在该作用域内实例化的，因此作用域结束时自动析构。
然后再创建一个线程对象，也是t。再执行。然后等待。最后析构。如此往复4次。
构造函数下面我们详解一下构造函数
第一个参数是函数对象，可以用普通函数、成员函数，functor，lambda等。
假如用lambda(我个人比较喜欢，简洁干净）#include#includeusing namespace std;
int main()
{ for (int i = 0; i< 4; i++)
{thread t([i](){ cout<< i<< endl;
});
t.join();
}
return 0;
} 这种方式要注意：不能使用thread t(Task(), i);。尽管这个有可能不出BUG，但是也有可能会出BUG。因为编译器会认为你在进行函数声明。如果你非想要创建一个匿名变量，那么请用{}
#include#includeusing namespace std;
class Task
{public:
void operator()(int i)
{cout<< i<< endl;
}
};
int main()
{for (int i = 0; i< 4; i++)
{Task task;
thread t(task, i);
//do not use this, because it may be viewed as a function declaration
//thread t(Task(), i);
//If you want to use this, you should use initializer_list
//thread t{(Task()), i};
t.join();
}
return 0;
} 这类方式最麻烦，因为第二个参数还需要传入所对应的对象的指针。
#include#includeusing namespace std;
class Task
{public:
void do_work(int i)
{cout<< i<< endl;
}
};
int main()
{cout<<"member func"<Task task;
thread t(&Task::do_work, &task, i);
t.join();
}
return 0;
} 上面说的都是join的例子。因为join会阻塞主线程，等待子线程的执行完毕，所以不会出现乱序的BUG。但是如果detach，那么子线程就是放飞自我，主线程也不会等待子线程，导致谁也不知道哪个子线程先执行完毕。
一个有BUG的程序#include#includeusing namespace std;
void output(int i)
{cout<< i<< endl;
}
int main()
{cout<<"detach thread\n";
for (uint8_t i = 0; i< 4; i++)
{thread t(output, i);
t.detach();
}
getchar();
return 0;
} 输出
detach thread
02
3
1这显然是个有BUG的程序。因为子线程放飞自我之后，你根本无法预测哪个先结束。你甚至不能保证主线程main函数最后return 0。因为有可能主线程结束了，子线程还在运行着呢。
信不信由你：如果你不加上getchar();你甚至可能什么都打印不出来。因为主线程先结束了，子线程还没结束呢。
detach另外一个错误是容易导致悬空指针。
#include#includeusing namespace std;
int main()
{auto fn = [](const int *a)
{for (int i = 0; i< 10; i++)
{ cout<< *a<< endl;
}
};
cout<< "detach thread another bug\n";
[fn]
{int a = 1010;
thread t(fn, &a);
t.detach();
}();
} 在这个例子中，a的地址被传给子线程的fn函数。但是由于是detach，主线程不需要等待子线程。这就导致很可能主线程已经执行完毕，并且销毁了a变量，导致这个指针是个悬空的指针。
正确的改进方式是把传递指针改成传值。
因此在多线程的程序中，通常都采用传值而非传址。
即使是传递引用也会变成拷贝传值为了防止上述错误，C++规定：即使是传递引用，也会变成拷贝。
例如
#include#includeusing namespace std;
class Node
{public:
int a = 1;
int b = 2;
};
void func(Node &node)//will become copy even if we pass by reference
{node.a = 10;
node.b = 20;
}
int main()
{Node node;
thread t(func, node);
t.join();
cout<< node.a<< endl ;
cout<< node.b<< endl ;
} output
1
2在上面的例子中，即使我们指定了传递引用，也会变成拷贝。所以func根本没改变node原有的值。所以最后打印出来还是1 2。
获取线程的id有两种方式获取id
- 从子线程内获取
this_thread::get_id() - 从外部主线程获取
t.get_id()
#include#includeusing namespace std;
void func()
{
cout<< "In func thread id:"< 输出
In main thread id:27424
In func thread id:27424
-----------------
In main thread id:20068
In func thread id:20068
-----------------
In main thread id:19404
In func thread id:19404
-----------------
In main thread id:21680
In func thread id:21680
-----------------mutex
condition_variable
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网站名称：【并行】std::thread入门-创新互联
标题链接：http://mswzjz.cn/article/dipdps.html