C++ —— 线程

奶香臭豆腐

已于 2025-03-11 10:19:46 修改

阅读量1.6k

点赞数 52

文章标签：开发语言 c++

于 2025-03-10 16:09:38 首次发布

本文链接：https://blog.youkuaiyun.com/MaoSiri/article/details/145681635

版权

C++ —— 线程

引言
线程的特点
创建线程
其他创建线程的函数
线程类无拷贝构造函数
线程资源回收

引言

单任务模式的特点是：必须在完成一个任务之后才能去执行其他任务。如果在当前任务中间插入其他任务，当前任务就会被推后。单任务模式的代码示例如下：

#include <iostream>
#include <chrono> // Linux系统用std::this_thread::sleep_for
using namespace std;

int main() {
    cout << "start task" << endl;
    for (int i = 0; i < 10; i++) {
        cout << "task execution..." << endl;
        std::this_thread::sleep_for(std::chrono::seconds(1)); // 这行个下面一行代码效果一样
        // this_thread::sleep_for(chrono::milliseconds(1000));
    }
    cout << "task completed!" << endl;

    return 0;
}

如果想在同一时间执行多个任务，可以用多线程。
在计算机科学中，线程是程序执行中的最小单位。一个进程可以包含多个线程，而这些线程共享进程的资源（如内存、文件句柄等）。线程有时被称为轻量级进程，因为它们与进程相比，具有较小的开销和较低的管理成本。线程是并发执行的基本单位，能够并行执行程序中的不同部分。（点解浏览进程简介）

线程的特点

共享资源：同一进程中的多个线程共享进程的资源（如内存空间、文件描述符等），但是每个线程都有自己的寄存器、栈和线程本地存储（TLS）；
并发性和并行性：多个线程可以在同一个程序中并发执行（在多核处理器上可能并行执行），这有助于提高程序的响应性和性能；
独立调度：线程可以独立于其他线程进行调度和执行，操作系统会根据调度算法来决定哪个线程应该执行。

创建线程

头文件：#include <thread>
线程类：std::thread
线程类的构造函数有三种形式：

thread() noexcept; 默认构造函数，构造一个线程对象，不执行任何任务（不会创建/启动子线程）；
构造函数是一个模板函数（绝大多数情况下是使用这个构造函数）；
thread(thread&& other ) noexcept; 移动构造函数，将线程other的资源所有权转移给新创建的线程对象。原来的线程对象不再代表线程。

下面讲述第二种构造函数：

template< class Function, class... Args > explicit 
thread(Function&& fx, Args&&... args );

第一个参数Function是函数对象，第二个参数Args是可变参数包。这个构造函数的意思是：创建线程对象，在线程中执行任务函数fx中的代码，args是要传递给任务函数fx的参数。
任务函数fx可以是普通函数、类的非静态成员函数、类的静态成员函数、lambda函数、仿函数。

第二种构造函数创建线程对象的示例代码如下：

#include <iostream>
#include <string>
#include <chrono> // Linux系统用std::this_thread::sleep_for时需要导入该头文件
#include <thread> // 线程库的头文件
using namespace std;

void func (int n, const string& s) {
    for (int i = 0; i < 10; i++) {
        cout << "No." << n << " " << s << endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main() {
    // 在main函数中创建线程，让线程执行func函数中的任务
    std::thread t1(func, 1, "Hello!");
    // 创建线程对象，对象名为t1，使用第二种构造函数。
    // 第一个参数是线程要执行的函数名func，后面是传递给这个func函数的参数。

    cout << "start task" << endl;
    for (int i = 0; i < 10; i++) {
        cout << "task execution..." << endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    cout << "task completed!" << endl;

    t1.join(); // 等待线程t1执行完，回收t1线程资源。

    return 0;
}

在上面这段示例代码中，main函数中的代码叫做主程序、主线程或主进程，对象t1是子线程。主线程只能有一个、子线程可以有很多个，与计算机的硬件有关，硬件越好可以创建更多的子线程。普通电脑可以创建几百个，好的服务器可以创建几千个。
如果没有正确链接pthread，编译器会报undefined reference to pthread_create错误。解决方法：添加选项链接pthread库。
编译指令是：

g++ -o 可执行文件名 源代码名.cpp -pthread

再创建一个线程，让程序可以同时执行三个任务，main函数中的代码如下：

int main() {
    // 在main函数中创建线程，让线程执行func函数中的任务
    std::thread t1(func, 1, "Hello!");
    // 创建线程对象，对象名为t1，使用第二种构造函数。
    // 第一个参数是线程要执行的函数，后面是传递给这个函数的参数。
    std::thread t2(func, 222, "你好！");

    cout << "start task" << endl;
    for (int i = 0; i < 10; i++) {
        cout << "task execution..." << endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    cout << "task completed!" << endl;

    t1.join(); // 等待线程t1执行完，回收t1线程资源。
    t2.join();

    return 0;
}

运行程序时可能会出现奇怪的显示效果，请浏览这篇文章（）。

其他创建线程的函数

示例代码如下：

// lambda函数
auto f = [](int n, const string& s) {
    for (int i = 0; i < 10; i++) {
        cout << "No." << n << " " << s << endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
};

// 仿函数
class mythread_1 {
public:
    void operator()(int n, const string& s) {
        for (int i = 0; i < 10; i++) {
            cout << "No." << n << " " << s << endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
};

// 类中有静态成员函数
class mythread_2 {
public:
    static void func(int n, const string& s) {
        for (int i =  0; i < 10; i++) {
            cout << "No." << n << " " << s << endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
};

// 类的普通成员函数
class mythread_3 {
public:
    void func(int n, const string& s) {
        for (int i =  0; i < 10; i++) {
            cout << "No." << n << " " << s << endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
};

int main () {
    // std::thread t3(f, 333, "Hi~Hi~Hi~");
    // std::thread t4(mythread_1(), 444, "heiheihei");
    // std::thread t5(mythread_2::func, 555, "fff");
    
    // 类的普通成员函数创建线程
    // 先创建类的对象，还必须保证对象的生命周期比子线程要长
    // mythread_3 mt;
    // std::thread t6(&mythread_3::func, &mt, 666, "hahaha");
    // 第一个参数是成员函数的地址，第二个参数是对象地址，也就是this指针，后面是传递给成员函数的参数。

	// 此处省略...

	// t3.join();
    // t4.join();
    // t5.join();
    // t6.join();
	return 0;
}

跟之前一样的重复代码大家自行填补一下

线程类无拷贝构造函数

thread(const thread& ) = delete;
线程类删除了拷贝构造函数，不允许线程对象之间的拷贝。

线程资源回收

如下代码中，主线程、子线程t1和t2都是运行10秒：

#include <iostream>
#include <chrono>
#include <thread>
#include <string>
using namespace std;

void func (int n, const string& s) {
    for (int i = 0; i < 10; i++) {// 子进程 运行10秒
        cout << "No." << n << " " << s << endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main() {
    std::thread t1(func, 1, "Hello!");
    std::thread t2(func, 222, "你好！");

    cout << "start task" << endl;
    for (int i = 0; i < 10; i++) {// 主进程 运行10秒
        cout << "task execution..." << endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    cout << "task completed!" << endl;

    t1.join();
    t2.join();
}

修改代码，使主线程运行5秒后先退出，子线程还是运行10秒后退出：

#include <unistd.h> // Linux系统用sleep

int main() {
    std::thread t1(func, 1, "Hello!");
    std::thread t2(func, 222, "你好！");

    cout << "start task" << endl;
    for (int i = 0; i < 5; i++) {// 主进程 运行5秒
        cout << "task execution..." << endl;
        // std::this_thread::sleep_for(std::chrono::seconds(1));
        sleep(1); // 效果相同
    }
    cout << "task completed!" << endl;
    return 0;

    t1.join();
    t2.join();
}

编译运行，5秒后主程序退出了，子线程也退出了。
如果主程序（主线程）退出（不论是正常退出还是意外终止），全部的子线程将强行被终止。
虽然同一个进程的多个线程共享进程的栈空间，但是，每个子线程在这个栈中拥有自己私有的栈空间。所以，线程结束时需要回收资源，如果不回收，会产生僵尸线程，程序还会报错。
回收子线程的资源有两种方法：

在主程序中，调用join()成员函数等待子线程退出，回收它的资源。如果子线程已退出，join()函数立即返回，否则会阻塞等待，直到子线程退出。

int main() {
    std::thread t1(func, 1, "Hello!");
    std::thread t2(func, 222, "你好！");

    cout << "start task" << endl;
    for (int i = 0; i < 12; i++) {// 主进程 运行5秒
        cout << "task execution..." << endl;
        // std::this_thread::sleep_for(std::chrono::seconds(1));
        sleep(1); // 效果相同
    }
    cout << "task completed!" << endl;
    return 0; 
    // 现在主线程12秒后结束，子线程10秒结束，子线程先结束，如果主线程不回收子线程资源，会异常退出。

    t1.join();
    t2.join();
    
    // return 0; // return 在此处此时正确的
}

在主程序中，调用detach()成员函数分离子线程，子线程退出时，系统将自动回收资源。分离后的子线程不可join()。

int main() {
    std::thread t1(func, 1, "Hello!");
    std::thread t2(func, 222, "你好！");

    t1.detach(); // 使t1、t2与主进程分离，在后台独立运行。
    t2.detach();

	sleep(15); // 让主进程序等待子线程运行完。等待时间比子线程时间长，子线程就能运行完。
    
    return 0;
}

joinable()用于检查线程是否可以join()或detach()，返回布尔类型：

如果线程已经启动且未被join()或detach()，返回true；
在未启动线程、已join()线程、已detach()线程时返回false。

示例代码如下：

#include <iostream>
#include <thread>

void func() {
    std::cout << "Thread is running..." << std::endl;
}

int main() {
    std::thread t(func);

    if (t.joinable()) {  // 避免非法 join
        t.join();
    }

    return 0;
}

感谢浏览