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需要读者自行探索和了解。
本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:c++11&14-多线程要点汇总 - Python技术站