C++并发

C++11 并发指南

与 C++11 多线程相关的头文件

C++11 新标准中引入了四个头文件来支持多线程编程,他们分别是 ,,,

  • :该头文主要声明了两个类, std::atomic 和 std::atomic_flag,另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。
  • :该头文件主要声明了 std::thread 类,另外 std::this_thread 命名空间也在该头文件中。
  • :该头文件主要声明了与互斥量(mutex)相关的类,包括 std::mutex 系列类,std::lock_guard, std::unique_lock, 以及其他的类型和函数。
  • :该头文件主要声明了与条件变量相关的类,包括 std::condition_variable 和 std::condition_variable_any。
  • :该头文件主要声明了 std::promise, std::package_task 两个 Provider 类,以及 std::future 和 std::shared_future 两个 Future 类,另外还有一些与之相关的类型和函数,std::async() 函数就声明在此头文件中。

    #include <stdio.h>
    #include <iostream>
    #include <thread>
    #include <stdlib.h>
    void thread_task(){
    std::cout<<"hello thread"<<std::endl;
    }
    
    int main(int argc,const char *argv[])
    {
    std::thread t(thread_task);
    t.join();
    
    return EXIT_SUCCESS;
    }

std::thread 在 头文件中声明,因此使用 std::thread 时需要包含 头文件。

std::thread 构造

(1). 默认构造函数,创建一个空的 thread 执行对象。

(2). 初始化构造函数,创建一个 thread对象,该 thread对象可被joinable,新产生的线程会调用 fn 函数,该函数的参数由 args 给出。

(3). 拷贝构造函数(被禁用),意味着 thread 不可被拷贝构造。

(4). move 构造函数,move 构造函数,调用成功之后 x 不代表任何 thread 执行对象。

move赋值操作

(1). move 赋值操作,如果当前对象不可 joinable,需要传递一个右值引用(rhs)给 move 赋值操作;如果当前对象可被 joinable,则 terminate() 报错。

(2). 拷贝赋值操作被禁用,thread 对象不可被拷贝。

#include <stdio.h>
#include <stdlib.h>

#include <chrono>    // std::chrono::seconds
#include <iostream>  // std::cout
#include <thread>    // std::thread, std::this_thread::sleep_for

void thread_task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "hello thread "
        << std::this_thread::get_id()
        << " paused " << n << " seconds" << std::endl;
}

/*
 * ===  FUNCTION  =========================================================
 *         Name:  main
 *  Description:  program entry routine.
 * ========================================================================
 */
int main(int argc, const char *argv[])
{
    std::thread threads[5];
    std::cout << "Spawning 5 threads...\n";
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(thread_task, i + 1);
    }
    std::cout << "Done spawning threads! Now wait for them to join\n";
    for (auto& t: threads) {
        t.join();
    }
    std::cout << "All threads joined.\n";

    return EXIT_SUCCESS;
}  /* ----------  end of function main  ---------- */

其他成员函数

  • gei_id 获取线程ID
  • joinable 检查线程是否可被join
  • detach Detach线程
  • swap Swap线程
  • native_handle 返回native_handle
  • hardware_concurrency[static] 检测硬件并发特性

std::mutex 详解

Mutex又称互斥量,c++11中与Mutex相关的类(包括锁类型)和函数都声明在头文件中,所以如果你需要使用 std::mutex,就必须包含 头文件。

头文件介绍

Mutex系列类(四种)

  • std::mutex,最基本的Mutex类
  • std::recursive_mutex,递归Mutex类
  • std::time_mutex,定义Mutex类
  • std::recursive_timed_mutex,定时递归Mutex类

Lock类

  • std::lock_guaed,方便线程对互斥量上锁
  • std::unique_lock,方便线程对互斥量上锁,提供更好的上锁和解锁控制

其他类型

  • std::once_flag
  • std::adopt_lock_t
  • std::defer_lock_t
  • std::try_to_lock_t

函数 * std::try_lock,尝试同时对多个互斥量上锁。 * std::lock,可以同时对多个互斥量上锁。 * std::call_once,如果多个线程需要同时调用某个函数

call_once 可以保证多个线程对该函数只调用一次。

std::mutex介绍

std::mutex 是C++11 中最基本的互斥量,std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁,而 std::recursive_lock 则可以递归地对互斥量对象上锁。

std::mutex 的成员函数 * 构造函数 std::mutex不允许拷贝构造,也不允许 move 拷贝,最初产生的 mutex 对象是处于 unlocked 状态的。 * lock(),调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况: * (1). 如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁。 * (2). 如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住。 * (3). 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。 * unlock(), 解锁,释放对互斥量的所有权。 * try_lock(),尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况, * (1). 如果当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量。 * (2). 如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉。 * (3). 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。

std::recursize_mutex介绍

std::recursive_mutex 与 std::mutex 一样,也是一种可以被上锁的对象,但是和 std::mutex 不同的是,std::recursive_mutex 允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock(),可理解为 lock() 次数和 unlock() 次数相同,除此之外,std::recursive_mutex 的特性和 std::mutex 大致相同。

std::time_mutex 介绍 std::time_mutex 比 std::mutex 多了两个成员函数,try_lock_for(),try_lock_until()。

try_lock_for 函数接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住(与 std::mutex 的 try_lock() 不同,try_lock 如果被调用时没有获得锁则直接返回 false),如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。

try_lock_until 函数则接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。

std::unique_lock 类 unique_lock 是通用互斥包装器,允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。 unique_lock比lock_guard使用更加灵活,功能更加强大。 使用unique_lock需要付出更多的时间、性能成本。


c++ 线程 join和detach

(1)当使用join()函数时,主调线程(main函数里有一个主调线程)阻塞,等待被调线程终止,然后主调线程回收被调线程资源,并继续运行;上面这段话的意思就是,使用join(),线程运行完,main函数才能结束。

(2)当使用detach()函数时,主调线程继续运行,被调线程驻留后台运行,主调线程无法再取得该被调线程的控制权。当主调线程结束时,由运行时库负责清理与被调线程相关的资源。上面这段话的意思就是,使用detach(),main函数不用等待线程结束才能结束。有时候线程还没运行完,main函数就已经结束了。

**

点击刷新