C++11封装thread库的方法示例

本文讲解在C++11中如何使用thread库进行线程管理，通过封装实现线程安全的应用程序。

为什么要使用线程

在计算机科学中，线程表示程序中执行的一条路径。一个进程通常包含一个或多个线程，多个线程可以并行执行，提高程序的处理效率；同时，也方便了对于程序中复杂、耗时的操作的调度和管理。

介绍封装thread库的方法

C++11中引入了thread库，其支持创建和管理线程。以下是使用C++11封装thread库的方法。

步骤1：包含头文件

在代码开头需要引入thread头文件以下代码：

#include <thread>

步骤2：定义线程的执行函数

定义一个函数，作为新建线程的执行函数。例如：

void threadFunction(int value)
{
    for (int i = 0; i < value; ++i)
    {
        std::cout << "Thread function executing\n";
    }
}

步骤3：创建线程

使用std::thread类创建新的线程，新建的线程将执行threadFunction函数，并将其参数传递给该函数。例如：

std::thread myThread(threadFunction, 3);

步骤4：等待线程结束

使用join()方法，等待线程执行完成。例如：

myThread.join();

示例1：计算斐波那契数列

以下代码展示如何封装C++11的thread库，计算斐波那契数列：

#include <iostream>
#include <thread>

void  fibonacci(uint32_t n, uint32_t& result)
{
    if (n == 0)
    {
        result = 0;
        return;
    }

    if (n == 1 || n == 2)
    {
        result = 1;
        return;
    }

    uint32_t pre1 = 1;
    uint32_t pre2 = 1;
    uint32_t cur = 0;

    for (int i = 3; i <= n; ++i)
    {
        cur = pre1 + pre2;
        pre1 = pre2;
        pre2 = cur;
    }

    result = cur;
}

int main()
{
    std::cout << "Fibonacci computation starts\n";

    uint32_t result;

    std::thread myThread(fibonacci, 10, std::ref(result));

    myThread.join();

    std::cout << "Fibonacci result is " << result << std::endl;

    return 0;
}

在以上示例中，fibonacci函数是一个计算斐波那契数列的函数，由于计算斐波那契数列比较耗时，因此将其放在另一个线程中运行；main函数中则调用该函数并等待其返回结果。

示例2：线程安全的队列

以下代码展示如何封装C++11的thread库，创建一个线程安全的队列：

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>

template<typename T>
class ThreadSafeQueue
{
public:
    void push(const T& value)
    {
        std::unique_lock<std::mutex> lock(m_mutex);

        m_queue.push(value);

        m_condVar.notify_one();
    }

    void waitAndPop(T& value)
    {
        std::unique_lock<std::mutex> lock(m_mutex);

        m_condVar.wait(lock, [this] { return !m_queue.empty(); });

        value = m_queue.front();
        m_queue.pop();
    }

private:
    std::queue<T> m_queue;
    std::mutex m_mutex;
    std::condition_variable m_condVar;
};

void ThreadFunction(ThreadSafeQueue<int>& queue)
{
    int value = 0;

    queue.waitAndPop(value);

    std::cout << "Thread function executed. Popped value: " << value << std::endl;
}

int main()
{
    ThreadSafeQueue<int> queue;

    std::thread myThread(ThreadFunction, std::ref(queue));

    queue.push(42);

    myThread.join();

    return 0;
}

在以上示例中，ThreadSafeQueue 类是一个简单的线程安全队列，包含了push方法和waitAndPop方法，分别可以向队列中插入元素和从队列中取出元素。ThreadFunction函数则将这个线程安全队列作为参数，从其中取出元素并打印。

总结

本文介绍了C++11封装thread库的方法，包括创建线程、等待线程执行完毕、使用线程安全队列等方面。示例程序展示了一些常见的线程管理问题如何解决，在实际编程中开发者可以结合自己的需求进行相应的修改和扩展。