C++ 20新特性之线程与jthread

为什么要引入jthread

在C++ 11中，已经引入了std::thread。std::thread为C++标准库带来了一流的线程支持，极大地促进了多线程开发的便利性。但std::thread也存在一些明显的不足和短板，主要有以下几点。

1、生命周期管理的复杂性。std::thread对象必须在它代表的线程结束之前，一直保持存活。如果一个std::thread对象被销毁（比如：离开了其作用域），而它关联的线程还在运行，那么程序会调用std::terminate()终止，除非线程被join或者detach过。这就要求我们必须仔细管理每个线程对象的生命周期，大大增加了编码的复杂度和出错的可能性。

2、缺乏自动资源管理。std::thread没有自动管理线程生命周期的机制，程序员必须显式调用join或detach。否则，可能导致资源泄露或程序异常终止，这在异常处理场景下尤为麻烦。

3、异常安全性问题。如果在创建或启动std::thread时发生异常，可能会导致资源泄露或者程序的不确定行为。比如：如果在std::thread构造函数中抛出了异常，那么已经创建的线程可能无法正确地被join或detach。

为了解决这些问题，C++ 20中引入了std::jthread。

自动管理生命周期

C++ 20中新引入的std::jthread解决了C++ 11中std::thread的一些不便之处，特别是在线程生命周期管理上的自动化处理。std::jthread是一个智能指针风格的类，它自动join或detach与之关联的线程，从而避免了潜在的资源泄露问题。

接下来，我们通过一个具体的例子来理解std::jthread的工作原理。

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

void RunTask(stop_token stoken)
{
    int nCount = 0;
    while (!stoken.stop_requested())
    {
        cout << "Task running... " << nCount++ << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }

    cout << "Task stopped" << endl;
}

int main()
{
    jthread t(RunTask);
    // 主线程等待一段时间
    this_thread::sleep_for(chrono::seconds(5));
    return 0;
}

在上面的示例代码中，RunTask函数作为工作线程的入口点，接收一个std::stop_token参数，用于检测是否请求停止。std::jthread t(RunTask)声明了一个jthread对象t，它会自动管理task函数所在线程的生命周期。当main函数结束时，t会自动调用join，等待关联线程完成或终止。可以看到，虽然我们没有显式要求停止线程，但当main函数返回时，jthread会确保线程安全结束。执行这段代码，其输出如下。

Task running... 0
Task running... 1
Task running... 2
Task running... 3
Task running... 4
Task stopped

stop_source和stop_token

与std::thread相比，std::jthread的强大之处在于它与std::stop_source和std::stop_token的集成，从而允许我们优雅地请求线程停止。

在下面的示例代码中，通过创建std::stop_source对象，并将其get_token方法的结果传递给RunTask函数，我们可以在需要时通过stopSource.request_stop()请求线程停止。RunTask函数中会循环检查std::stop_token的状态，一旦请求停止，就会退出循环并清理资源。

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

void RunTask(stop_token stoken)
{
    int nCount = 0;
    while (!stoken.stop_requested())
    {
        // 子线程执行一些任务
        cout << "Working..." << nCount++ << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }

    cout << "Task stopped" << endl;
}

int main()
{
    stop_source stopSource;
    jthread t(RunTask, stopSource.get_token());

    // 主线程等待一段时间
    this_thread::sleep_for(chrono::seconds(3));
    cout << "Request task to stop..." << endl;

    // 主动请求线程停止
    stopSource.request_stop();
    return 0;
}

执行上述代码，其输出如下。

Working...0
Working...1
Working...2
Request task to stop...
Task stopped

线程中使用成员函数

std::jthread不仅可以用来启动普通函数，还可以用来启动类的成员函数。此时，需要使用lambda表达式来传递对象实例和成员函数指针。具体的用法，可以参考下面的示例代码。

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

class CTask
{
public:
    void Run(stop_token stoken)
    {
        int nCount = 0;
        while (!stoken.stop_requested())
        {
            cout << "Working..." << nCount++ << endl;
            this_thread::sleep_for(chrono::seconds(1));
        }
    }
};

int main()
{
    CTask task;
    jthread t([&task](stop_token stoken){ task.Run(stoken); });
    this_thread::sleep_for(chrono::seconds(5));
    return 0;
}

在上面的示例代码中，我们首先定义了一个名为CTask的类，其中包含一个公共成员函数Run。这个函数接收一个stop_token参数，用于检查是否有停止线程的请求。函数内部，它使用一个循环不断地输出计数器的值，并在每次循环之间暂停1秒。当stop_token表示停止请求时，循环结束。

在main函数中，我们创建了CTask类的对象task。接着，声明了一个jthread对象t，并初始化它以执行一个Lambda函数。这个Lambda函数捕获了task对象的引用，并将其传递给task.Run()方法，同时也传入了stop_token。jthread会自动为这个Lambda函数提供一个与之关联的stop_token，用于线程的停止请求。当jthread对象t的生命周期结束时，它会自动调用join来等待线程结束，无需手动调用join或detach。