C++11 Thead线程库的基本使用

创建线程

要创建线程，我们需要一个可调用的函数或函数对象，作为线程的入口点。在C++11中，我们可以使用函数指针、函数对象或lambda表达式来实现。

创建线程的基本语法如下：

#include //头文件
using namespace std;
thread t(function_name, args...);

`function_name`是线程入口点的函数或可调用对象

`args...`是传递给函数的参数
1
2
3
4
5
6
7

创建线程后，我们可以使用t.join()等待线程完成，或者使用t.detach()分离线程，让它在后台运行。

#include 
#include 
using namespace std;
void print_message() 
{
    cout << "Hello, world!" << endl;
}
int main() 
{
    std::thread t(print_message); 
	t.join();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

我们定义了一个名为print_message的函数，它输出一条消息。
然后，我们创建了一个名为t的线程，将print_message函数作为入口点。
最后，我们使用t.join()等待线程完成。

传递参数

我们可以使用多种方式向线程传递参数，例如使用函数参数、全局变量、引用等。如：

#include 
#include 
using namespace std;
void print_message(const string& message)
{
    cout << message << endl;
}
void increment(int& x)
{
    ++x;
}
int main() 
{
    string message = "Hello, world!";
    thread t(print_message, message);
    t.join(); 
	int x = 0;  
    thread t2(increment, ref(x));  
	t2.join();  
	cout << x << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在第一个例子中，我们使用了一个字符串作为函数参数，传递给线程。
在第二个例子中，我们使用了一个引用来传递一个整数变量。
需要注意的是，当我们使用引用传递参数时，我们需要使用std::ref来包装引用，否则编译器会报错。

等待线程完成

当我们创建一个线程后，我们可能需要等待它完成，以便获取线程的执行结果或执行清理操作。我们可以使用t.join()方法来等待线程完成。
例如，下面的代码创建了两个线程，等待它们完成后输出一条消息：

#include 
#include 
using namespace std;
void print_message(const std::string& message) 
{    
	std::cout << message << std::endl;
}
int main() 
{   
 thread t1(print_message, "Thread 1");  
 thread t2(print_message, "Thread 2");  
 t1.join();  
 t2.join();  
 cout << "All threads finished!" << endl;  
 return 0;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个例子中，我们创建了两个线程t1和t2，它们都调用print_message函数输出一条消息。
然后，我们使用t1.join()和t2.join()等待它们完成。最后，我们输出一条消息，表示所有线程都已经完成。

分离线程

有时候我们可能不需要等待线程完成，而是希望它在后台运行。
这时候我们可以使用t.detach()方法来分离线程。
例如，下面的代码创建了一个线程，分离它后输出一条消息：

#include 
#include 
using namespace std;
void print_message(const std::string& message)
{
 cout << message << endl;
}
 int main() 
{
 thread t(print_message, "Thread 1");
 t.detach(); 
 cout << "Thread detached" << endl;
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，我们创建了一个名为t的线程，调用print_message函数输出一条消息。
然后，我们使用t.detach()方法分离线程，让它在后台运行。
最后，我们输出一条消息，表示线程已经被分离。

需要注意的是，一旦线程被分离，就不能再使用t.join()方法等待它完成。
而且，我们需要确保线程不会在主线程结束前退出，否则可能会导致未定义行为。

joinable()

joinable()方法返回一个布尔值，如果线程可以被join()或detach()，则返回true，否则返回false。
如果我们试图对一个不可加入的线程调用join()或detach()，则会抛出一个std::system_error异常。

下面是一个使用joinable()方法的例子：

#include 
#include 
using namespace std;
void foo() 
{
    cout << "Thread started" << endl;
}
int main() 
{
    thread t(foo);
    if (t.joinable())
	{
        t.join();
    }
    cout << "Thread joined" << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

本文是作为自己的一个学习记录，学习的资源来源于链接