c++线程的简单例子

谁能举一个简单的例子，在c++中启动两个(面向对象的)线程。

我正在寻找实际的c++线程对象，我可以扩展运行方法(或类似的东西)，而不是调用C风格的线程库。

我省略了任何特定于操作系统的请求，希望回复的人会回复使用的跨平台库。我现在把它说得很清楚了。

882853 次浏览
小开

这在很大程度上取决于您决定使用的库。例如，如果你使用wxWidgets库，线程的创建看起来像这样:

class RThread : public wxThread {


public:
RThread()
: wxThread(wxTHREAD_JOINABLE){
}
private:
RThread(const RThread &copy);


public:
void *Entry(void){
//Do...


return 0;
}


};


wxThread *CreateThread() {
//Create thread
wxThread *_hThread = new RThread();


//Start thread
_hThread->Create();
_hThread->Run();


return _hThread;
}

如果主线程调用CreateThread方法，您将创建一个新线程，该线程将开始执行“条目”中的代码。方法。在大多数情况下，您必须保持对线程的引用才能加入或停止它。

更多信息在wxThread文档中。

小开

好吧，从技术上讲，任何这样的对象都将在C风格的线程库上构建，因为c++只是在c++ 0 x中指定了一个普通的std::thread模型，这个模型刚刚被确定下来，还没有实现。

这个问题有点系统性。从技术上讲，现有的c++内存模型还不够严格，无法为所有“happens before”情况提供定义良好的语义。汉斯·波姆不久前写了一篇关于这个主题的论文，并在关于这个主题的c++ 0x标准的制定中发挥了重要作用。

线程不能被实现为库

也就是说，有几个跨平台的线程c++库在实践中工作得很好。Intel线程构建块包含一个tbb:线程对象，它非常接近c++ 0x标准，提高有一个boost::线程库，它也有同样的功能。

使用boost::线程，你会得到类似的东西:

#include <boost/thread.hpp>


void task1() {
// do stuff
}


void task2() {
// do stuff
}


int main (int argc, char ** argv) {
using namespace boost;
thread thread_1 = thread(task1);
thread thread_2 = thread(task2);


// do other stuff
thread_2.join();
thread_1.join();
return 0;
}
小开
最佳答案

创建一个你想让线程执行的函数，例如:

void task1(std::string msg)
{
std::cout << "task1 says: " << msg;
}

现在创建thread对象，它最终将调用上面的函数，如下所示:

std::thread t1(task1, "Hello");

(你需要#include <thread>来访问std::thread类。)

构造函数的第一个参数是线程将要执行的函数，后面是函数的形参。线程在构造时自动启动。

如果稍后你想等待线程执行完函数，调用:

t1.join();

(连接意味着调用新线程的线程将等待新线程完成执行，然后再继续自己的执行。)

的代码

#include <string>
#include <iostream>
#include <thread>


using namespace std;


// The function we want to execute on the new thread.
void task1(string msg)
{
cout << "task1 says: " << msg;
}


int main()
{
// Constructs the new thread and runs it. Does not block execution.
thread t1(task1, "Hello");


// Do other things...


// Makes the main thread wait for the new thread to finish execution, therefore blocks its own execution.
t1.join();
}

更多关于std::thread的信息在这里

  • 在GCC上，使用-std=c++0x -pthread编译。
  • 这应该适用于任何操作系统，假设你的编译器支持这个( c++ 11)特性。
小开

还有一个用于POSIX操作系统的POSIX库。

检查兼容性:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>


void *task(void *argument){
char* msg;
msg = (char*)argument;
std::cout << msg << std::endl;
}


int main(){
pthread_t thread1, thread2;
int i1, i2;
i1 = pthread_create(&thread1, NULL, task, (void*) "thread 1");
i2 = pthread_create(&thread2, NULL, task, (void*) "thread 2");


pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
return 0;
}

使用-lpthread编译。

POSIX线程

小开 
#include <thread>
#include <iostream>
#include <vector>
using namespace std;


void doSomething(int id) {
cout << id << "\n";
}


/**
* Spawns n threads
*/
void spawnThreads(int n)
{
std::vector<thread> threads(n);
// spawn n threads:
for (int i = 0; i < n; i++) {
threads[i] = thread(doSomething, i + 1);
}


for (auto& th : threads) {
th.join();
}
}


int main()
{
spawnThreads(10);
}
小开

当搜索一个c++类在新线程中调用它自己的实例方法的例子时，这个问题就出现了，但是我们不能以这种方式使用这些答案。下面是一个例子:

Class.h

class DataManager
{
public:
bool hasData;
void getData();
bool dataAvailable();
};

Class.cpp

#include "DataManager.h"


void DataManager::getData()
{
// perform background data munging
hasData = true;
// be sure to notify on the main thread
}


bool DataManager::dataAvailable()
{
if (hasData)
{
return true;
}
else
{
std::thread t(&DataManager::getData, this);
t.detach(); // as opposed to .join, which runs on the current thread
}
}

注意，这个例子没有涉及到互斥或锁定。

小开

除非想在全局名称空间中使用单独的函数，否则可以使用lambda函数来创建线程。

使用lambda创建线程的主要优点之一是不需要将局部参数作为参数列表传递。我们可以使用相同的捕获列表，lambda的闭包属性将负责生命周期。

下面是示例代码:

int main() {
int localVariable = 100;


thread th { [=]() {
cout << "The value of local variable => " << localVariable << endl;
}};


th.join();


return 0;
}

到目前为止，我发现c++ lambdas是创建线程的最佳方式，特别是对于更简单的线程函数。


提交答案