【C++并发编程】（二）线程的创建、分离和连接

（二）线程的创建、分离和链接

创建线程：示例

线程（Thread）是并发执行的基本单位。在C++中，std::thread用于创建和管理线程。当你想在线程中执行某个有参数或无参数的函数时，你可以将该函数传递给std::thread创建的线程对象，以下是一些示例。

示例1：传递无参数函数

#include <iostream>
#include <thread>

void print_hello() {
    std::cout << "Hello from thread!\n";
}

int main() {
	// 创建一个 std::thread 类型的对象 t，并传递 print_hello作为t构造函数的参数。
    std::thread t(print_hello);
    t.join(); // 等待线程结束，下一节介绍其作用
    return 0;
}

示例2：传递带参数函数（拷贝）

#include <iostream>
#include <thread>

void print_number(int num) {
    std::cout << "Number: " << num << '\n';
}

int main() {
    int value = 42;
    std::thread t(print_number, value); // 创建线程，并传入参数（value 被拷贝给线程  ）
    t.join(); // 等待线程结束
    return 0;
}

示例3：传递带参数函数（使用引用或指针）

如果你希望在线程中修改传入的参数值，可以用std::ref来包装参数，以便在创建线程时传递其引用。

#include <iostream>
#include <thread>

void modify_number(int& num) {
    num *= 2;
    std::cout << "Modified number: " << num << '\n';
}

int main() {
    int value = 42;
    std::thread t(modify_number, std::ref(value)); // 创建线程，并传入参数的引用
    t.join(); // 等待线程结束
    std::cout << "Value in main: " << value << '\n'; // 验证值已被修改
    return 0;
}

Modified number: 84
Value in main: 84

示例4：传递多个参数

你可以传递多个参数给线程函数。

#include <iostream>
#include <thread>

void print_info(std::string name, int age) {
    std::cout << "Name: " << name << ", Age: " << age << '\n';
}

int main() {
    std::string name = "Alice";
    int age = 30;
    std::thread t(print_info, name, age); // 创建线程，并传入多个参数
    t.join(); // 等待线程结束
    return 0;
}

示例5：传递类的成员函数和实例

你还可以传递类的成员函数和类的实例给线程。

#include <iostream>
#include <thread>

class Person {
public:
    void say_hello(const std::string& greeting) {
        std::cout << greeting << " from " << name << '\n';
    }
    std::string name = "Bob";
};

int main() {
    Person person;
    // 当线程 t 开始执行时，它会调用 person 对象的 say_hello 函数，并以 "Hello" 作为参数。
    std::thread t(&Person::say_hello, &person, "Hello"); // 创建线程，并传入成员函数和对象指针
    t.join(); // 等待线程结束
    return 0;
}

线程的分离（detach）和连接（join）。

在C++中，线程的分离（detach）和连接（join）是用于管理线程生命周期的两种主要方式。当创建一个线程时，你可以选择让它独立运行（即分离），或者等待它完成执行（即连接）。

分离（detach）

当你调用std::thread::detach()方法时，你告诉线程库你不再关心这个线程的结束时间，并且你不需要获取它的返回值。线程将在后台独立运行，直到其函数返回，结束。

示例：

#include <iostream>  
#include <thread>  
#include <chrono>  
#include <ctime>  
#pragma warning(disable: 4996)
void thread_task() {  
	// 阻塞当前线程的执行，直到指定的时间间隔(2s)过去 
    std::this_thread::sleep_for(std::chrono::seconds(2));  
    auto now = std::chrono::system_clock::now();  
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);  
    std::cout << "Hello from detached thread at " << std::ctime(&now_c) << std::endl;  
}  
  
int main() {  
    auto start_time = std::chrono::system_clock::now();  
    std::time_t start_time_c = std::chrono::system_clock::to_time_t(start_time);  
    std::cout << "Main thread starts at " << std::ctime(&start_time_c) << std::endl;  

    std::thread t(thread_task); // 创建线程  
    t.detach(); // 分离线程  
  
    // 主线程将不会等待t的结束，而是继续执行  
    std::cout << "Main thread continues execution without waiting for the detached thread.\n";  
  
    // 让主线程休眠3s，以便观察分离线程的输出  
    std::this_thread::sleep_for(std::chrono::seconds(3));  
  
    auto end_time = std::chrono::system_clock::now();  
    std::time_t end_time_c = std::chrono::system_clock::to_time_t(end_time);  
    std::cout << "Main thread ends at " << std::ctime(&end_time_c) << std::endl;  
  
    return 0;  
}

在这个例子中，t线程将开始执行thread_task函数，并在调用t.detach()后立即返回主线程。主线程将继续执行，而不需要等待t线程的完成。

Main thread starts at Fri May  3 23:02:06 2024

Main thread continues execution without waiting for the detached thread.
Hello from detached thread at Fri May  3 23:02:08 2024

Main thread ends at Fri May  3 23:02:09 2024

开始和结束相差3秒。

连接（join）

当你调用std::thread::join()方法时，你告诉线程库你想要等待这个线程完成执行后再继续下去。调用join()的线程将被阻塞，直到被连接的线程执行完毕。

示例：

#include <iostream>  
#include <thread>  
#include <chrono>  
#include <ctime>  
#pragma warning(disable: 4996)
void thread_task() {  
	// // 休眠2s
    std::this_thread::sleep_for(std::chrono::seconds(2));  
    auto now = std::chrono::system_clock::now();  
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);  
    std::cout << "Hello from joined thread at " << std::ctime(&now_c) << std::endl;  
}  
  
int main() {  
    auto start_time = std::chrono::system_clock::now();  
    std::time_t start_time_c = std::chrono::system_clock::to_time_t(start_time);  
    std::cout << "Main thread starts at " << std::ctime(&start_time_c) << std::endl;  
  
    std::thread t(thread_task); // 创建线程  
  
    // 主线程将在这里阻塞，等待t的完成  
    t.join();  
  
    std::cout << "Main thread continues execution after the thread is joined.\n";  
    std::this_thread::sleep_for(std::chrono::seconds(3));  
    auto end_time = std::chrono::system_clock::now();  
    std::time_t end_time_c = std::chrono::system_clock::to_time_t(end_time);  
    std::cout << "Main thread ends at " << std::ctime(&end_time_c) << std::endl;  
  
    return 0;  
}

在这个例子中，t线程将开始执行thread_task函数，而主线程在调用t.join()时将阻塞，等待t线程完成。当t线程完成后，主线程将继续执行。

Main thread starts at Fri May  3 23:11:45 2024

Hello from joined thread at Fri May  3 23:11:47 2024

Main thread continues execution after the thread is joined.
Main thread ends at Fri May  3 23:11:50 2024

开始和结束相差5秒。