C++11&14-多线程要点汇总

在C++11和C++14标准中，多线程相关的API得到了极大的增强和改善，本文将总结介绍其中一些重要的关键点。

1. std::thread

std::thread是C++11中线程的关键类型，用于创建和管理线程。可以使用std::thread的构造函数来创建一个新的线程：

#include <iostream>
#include <thread>

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

int main()
{
    std::thread newThread(threadFunction);
    newThread.join();
}

在上面的代码中，我们创建了一个新的线程并将threadFunction作为线程的入口点，然后使用join等待线程完成执行。

2. 线程同步

在多线程应用中，通常需要对线程之间的数据进行同步以避免竞争条件。C++11中引入了一些支持线程同步的API，其中最常见的是std::mutex和std::lock_guard。std::mutex用于保护共享数据的访问，可以在多个线程之间安全地进行数据读写。std::lock_guard则是一个RAII封装，用来保证在离开作用域时解锁锁定的互斥量。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex g_mutex;

void threadFunction()
{
    std::lock_guard<std::mutex> lock(g_mutex);
    std::cout << "Hello from thread!\n";
}

int main()
{
    {
        std::lock_guard<std::mutex> lock(g_mutex);
        std::cout << "Hello from main!\n";
    }

    std::thread newThread(threadFunction);
    newThread.join();
}

在上述示例中，我们在threadFunction中使用了std::lock_guard<std::mutex>来保证线程安全访问std::cout。同时，在main函数中我们也使用了std::lock_guard<std::mutex>来保证线程安全访问共享变量g_mutex。

3. 原子操作

除了互斥量和锁之外，C++11引入了原子类型来提供并发安全的操作。可以使用std::atomic来创建原子变量。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> g_count(0);

void threadFunction()
{
    g_count++;
}

int main()
{
    std::thread newThread1(threadFunction);
    std::thread newThread2(threadFunction);
    newThread1.join();
    newThread2.join();
    std::cout << "Result: " << g_count << std::endl;
}

在上述示例中，我们使用了std::atomic<int>来创建原子变量g_count。threadFunction函数将会同时被两个线程调用，但是由于g_count是原子变量，所有的操作都是并发安全的。

4. 同步队列

std::condition_variable和std::unique_lock可以用于实现同步队列，可以将多个线程阻塞在同一个条件变量上，直到某个其他线程通知条件变量。

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

std::mutex g_mutex;
std::condition_variable g_condition;
std::queue<int> g_queue;

void producer()
{
    for (int i = 0; i < 10; i++) {
        std::lock_guard<std::mutex> lock(g_mutex);
        g_queue.push(i);
        g_condition.notify_one();
    }
}

void consumer()
{
    std::unique_lock<std::mutex> lock(g_mutex);
    while (g_queue.empty()) {
        g_condition.wait(lock);
    }

    while (!g_queue.empty()) {
        int value = g_queue.front();
        g_queue.pop();
        std::cout << "Consumed value: " << value << std::endl;
    }
}

int main()
{
    std::thread producerThread(producer);
    std::thread consumerThread(consumer);
    producerThread.join();
    consumerThread.join();
}

在上述示例中，我们使用了std::condition_variable和std::unique_lock<std::mutex>来实现了一个同步队列，生产者线程不断地将数据推入队列，消费者线程一直等待，直到队列不为空。当队列不为空时，消费者线程会开始取出数据并处理。

总结

C++11和C++14中的多线程API为我们提供了更加安全高效的并发编程手段，除了上述介绍的内容，还有std::future、std::async、std::packaged_task、std::atomic_flag等类型和API需要读者自行探索和了解。

阅读剩余 66%