C++11 之 thread线程类_c++11 thread-优快云博客

在C++11之前，C / C++一直是一种顺序的编程语言。顺序是指所有指令都是串行执行的，即在相同的时刻，有且仅有单个CPU的程序计数器指向可执行代码的代码段，并运行代码段中的指令。而C / C++代码也总是对应地拥有一份操作系统赋予进程的包括堆、栈、可执行的（代码）及不可执行的（数据）在内的各种内存区域。

在C++11 标准中，增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。

一、thread是什么？

std::thread 是 C++ 标准库中的一个类，用于创建和管理线程。它提供了一种在 C++ 中实现多线程编程的方式。

通过 std::thread，您可以创建新的线程并在其中执行函数或者可调用对象。线程可以并行地执行代码，使得您可以在同一程序中同时执行多个任务。

二、thread类构造函数

构造函数接受可调用对象作为参数

构造函数接受可调用对象作为参数'func'构造函数接受可调用对象作为参数'args',创建一个新的线程对象，并执行'func'函数，函数参数为'args'

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

使用示例：

    void myFunction(int param)
    {
        std::cout << "例子1输出:" << std::endl;
        std::cout << "myFunction:" << param << std::endl;
    }

    std::thread myThread1(myFunction, 42);
    myThread1.join();

    int value = 10;
    std::thread myThread2([value](int param)
    {
        std::cout << "例子2输出:" << std::endl;
        std::cout << "myLambda:" << param;
    }, 24);
    myThread2.join();

输出结果：

构造函数接受成员函数指针和对象实例作为参数

template< class Class, class... Args >
explicit thread( Class&& obj, Args&&... args );

使用示例：

    class MyClass
    {
    public:
        void printHelloWorld() const
        {
            std::cout << "子线程输出:" << std::endl;
            std::cout << "类成员函数和对象实例作为线程类thread参数:" << std::endl;
        }
    };

    MyClass obj;
    std::thread myThread(&MyClass::printHelloWorld, &obj);
    myThread.join();

输出结果：

构造函数接受函数对象（仿函数）作为参数

template< class Callable, class... Args >
explicit thread( Callable&& f, Args&&... args );

使用示例：

    struct MyClass
    {
        void operator()()
        {
            std::cout << "子线程输出" << std::endl;
            std::cout << "仿函数作为线程类thread参数" << std::endl;
        }
    };
    
    MyClass myClass;
    std::thread myThread4(myClass);
    myThread4.join();

结果输出：

三、thread类公共成员函数

1、get_id()

获取线程ID，类型为std::thread::id，用于获取当前线程的ID，每个线程仅有一个唯一的ID。

使用示例：

    std::cout << "主线程ID:" << std::this_thread::get_id()<<std::endl;

    std::thread myThread([]()
    {
            std::cout << "子线程ID:" << std::this_thread::get_id()<<std::endl;
    });
    std::cout << "子线程ID:" << myThread.get_id() << std::endl;
    myThread.join();

结果输出：

2、join()

"join()"是"std::thread"的一个成员函数，用于等待线程执行完毕。调用"join()"函数将阻塞当前线程，知道被调用的线程执行完毕。

使用示例：

#include <iostream>
#include <thread>

void myFunction() {
    // 线程执行的函数
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread executing..." << std::endl;
    }
}

int main() {
    std::thread myThread(myFunction);  // 创建线程并执行 myFunction

    // 其他操作...

    myThread.join();  // 等待线程执行完成

    std::cout << "Main thread continues..." << std::endl;

    return 0;
}

结果输出：

3、detach()

"detach()"用于将线程与实际的线程分离，分离后线程在后台继续执行，与主线程无关。主线程不再追踪和控制分离的线程。子线程任务执行完毕后，将自动是否自己占用的系统资源

使用示例：

#include <iostream>
#include <thread>

void myFunction() {
    // 线程执行的函数
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread executing..." << std::endl;
    }
}

int main() {
    std::thread myThread(myFunction);  // 创建线程并执行 myFunction

    // 其他操作...

    myThread.detach();  // 分离线程，使其在后台继续执行

    std::cout << "Main thread continues..." << std::endl;

    // 等待子线程执行完毕
    std::this_thread::sleep_for(std::chrono::seconds(5));

    return 0;
}

结果输出：

4、joinable()

"joinable()"是"std::thread"类的一个成员函数，用于检查线程是否可以被"join()"或"detach()"。如果线程对象尚未与实际的线程关联，或者已经被"join()"或 "detach()"，则该函数返回"false“，否则返回”true“。

使用示例：

#include <iostream>
#include <thread>

void myFunction() {
    // 线程执行的函数
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread executing..." << std::endl;
    }
}

int main() {
    std::thread myThread(myFunction);  // 创建线程并执行 myFunction

    // 其他操作...

    if(myThread.joinable())
    {
        std::cout << "joinable:" << (myThread.joinable() ? "true" : "false") <<std::endl;

        myThread.join();

        std::cout << "joinable:" << (myThread.joinable() ? "true" : "false") <<std::endl;
    }

    std::cout << "Main thread continues..." << std::endl;

    return 0;
}

结果输出：

5、swap

”swap“用于交换两个线程对象的状态。它将两个线程对象之间的执行内容进行交换，使得一个线程对象接管另一个线程对象的执行。

使用示例：

#include <iostream>
#include <thread>

void myFunction1() {
    std::cout << "Thread 1 executing..." << std::endl;
}

void myFunction2() {
    std::cout << "Thread 2 executing..." << std::endl;
}

int main() {
    std::thread thread1(myFunction1);  // 创建线程1，并执行 myFunction1
    std::thread thread2(myFunction2);  // 创建线程2，并执行 myFunction2

    // 其他操作...

    thread1.swap(thread2);  // 交换两个线程对象的执行内容

    // 其他操作...

    thread1.join();  // 等待线程1执行完成
    thread2.join();  // 等待线程2执行完成

    std::cout << "Main thread continues..." << std::endl;

    return 0;
}

结果输出：

四、thread类静态函数

1、hardware_concurrency()

"hardware_concurrency()"用于获取系统支持的并发线程数。它返回一个表示支持的并发线程数的无符号整数值。

使用示例：

#include <iostream>
#include <thread>

int main() {
    unsigned int numThreads = std::thread::hardware_concurrency();
    std::cout << "Number of concurrent threads supported: " << numThreads << std::endl;

    return 0;
}

结果输出：