【C++】C++多线程库的使用(1)

简介: 【C++】C++多线程库的使用

在C++11之前,涉及到多线程问题,都是和平台相关的,比如windowslinux下各有自己的接口,这使得代码的可移植性比较差,如果想要多平台能够同时运行就要使用条件编译写两份代码。

C++11中最重要的特性就是对线程进行支持了,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念。要使用标准库中的线程,必须包含头文件。

一、线程库(thread)

使用线程库,必须包含 < thread > 头文件。

1、线程的id类

在了解线程库之前我们先讲一个前置知识,我们知道每个线程都要有自己的线程id,在线程库类中有一个内嵌类型id类,此类是用数字表示的是线程id,并且此id类支持比较和流插入运算符

2、线程对象的构造

线程对象的构造函数如下:

  1. thread提供了无参的构造函数,调用无参的构造函数创建出来的线程对象没有关联任何线程函数,内部只有线程对象的相关属性但是没有启动任何线程, 此时线程的id0
  2. thread的带参的构造函数,是一个可变参数模板函数,参数说明如下:
  • fn:可调用对象,比如函数指针、仿函数、lambda表达式、被包装器包装后的可调用对象等。
  • args... : 调用可调用对象fn时所需要的若干参数。
  1. 线程是不允许拷贝的,所以其拷贝函数是delete的。
  • 同理线程对象也只允许移动赋值
  1. thread提供了移动赋值函数,因此当后续需要让该无参的线程对象与线程关联时,可以以带参的方式创建一个匿名对象,然后调用移动赋值将该匿名对象关联线程转移给该无参的线程对象。
void func(int n)
{
  for (int i = 0; i <= n; i++)
  {
    cout << i << endl;
  }
}
int main()
{
  // 创建无参的线程对象
  thread t1;
  // 移动构造
  t1 = thread(func, 10);
  t1.join();
  return 0;
}

3、thread提供的其他成员函数

thread中常用的成员函数如下:

成员函数 功能
join 对该线程进行等待,在等待的线程返回之前,调用join函数的线程将会被阻塞
joinable 判断该线程是否已经执行完毕,如果是则返回true,否则返回false
detach 将该线程与创建线程进行分离,被分离后的线程不再需要创建线程调用join函数对其进行等待
get_id 获取该线程的id
swap 将两个线程对象关联线程的状态进行交换

说明:

  • thread类是防拷贝的,不允许拷贝构造和拷贝赋值,但是可以移动构造和移动赋值,可以将一个线程对象关联线程的状态转移给其他线程对象,并且转移期间不影响线程的执行。
  • 线程结束以后其线程id会变为0
  • 对同一个线程join两次会导致程序崩溃

4、this_thread命名空间

this_threadstd命名空间下的一个子命名空间,此命名空间提供了访问当前线程的一组函数。

函数 功能
get_id 获得当前线程的id
yield 当前线程“放弃”执行,让出时间片,让操作系统调度另一线程继续执行
sleep_until 让当前线程休眠到一个具体时间点
sleep_for 让当前线程休眠一个时间段

我们调用thread的成员函数get_id可以获取线程的id,但该方法必须通过线程对象来调用get_id函数,如果要在线程对象关联的线程函数中获取线程id,可以调用this_thread命名空间下的get_id函数。

void func()
{
  //获取线程id
  cout << this_thread::get_id() << endl;
}
int main()
{
  thread t(func);
  t.join();
  return 0;
}

5、线程函数的参数问题

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的,就算线程函数的参数为引用类型,在线程函数中修改后也不会影响到外部实参,因为其实际引用的是线程栈中的拷贝,而不是外部实参。比如:

void add(int& num)
{
  num = 10;
}
int main()
{
  int num = 0;
  thread t(add, num);
  t.join();
  cout << num << endl; //0
  return 0;
}

ps :这段代码可能在vs等编译器下报错,不过不用在意,这种写法的使用也不正确

如果我们想要通过形参改变外部实参时,必须采用以下3种方式:

  1. 如果是引用,传参时可以借助std::ref()函数。
  2. 通过地址的拷贝,利用解引用来修改实参
  3. 利用lambda函数的捕捉列表,以引用的方式对外部实参进行捕捉
#include <thread>
void ThreadFunc1(int& x)
{
  x += 10;
}
void ThreadFunc2(int* x)
{
  *x += 10;
}
int main()
{
  int a = 10;
  // 如果想要通过形参改变外部实参时,必须借助std::ref()函数
  thread t1(ThreadFunc1, std::ref(a));
  t1.join();
  cout << a << endl;
  // 利用地址的拷贝,也能改变外部实参
  thread t2(ThreadFunc2, &a);
  t2.join();
  cout << a << endl;
  // 利用lambda表达式的捕捉列表
  thread t3([&] {a += 10; });
  t3.join();
  cout << a << endl;
  return 0;
}

二、互斥量库(mutex)

使用互斥量库,必须包含 < mutex > 头文件。

1、mutex的种类

在C++11中,mutex总共包了四个互斥量的种类:


  • mutex

mutex锁是C++11提供的最基本的互斥量,mutex对象之间不能进行拷贝。

mutex中常用的成员函数如下:

成员函数 功能
lock 对互斥量进行加锁
try_lock 尝试对互斥量进行加锁,如果加锁失败就立即返回,不会阻塞在锁上
unlock 对互斥量进行解锁,释放互斥量的所有权

线程函数调用lock时,可能会发生以下三种情况:

  • 如果该互斥量当前没有被其他线程锁住,则调用线程将该互斥量锁住,直到调用unlock之前,该线程一致拥有该锁。
  • 如果该互斥量已经被其他线程锁住,则当前的调用线程会被阻塞。
  • 如果该互斥量被当前调用线程锁住,则会产生死锁(deadlock)。

线程调用try_lock时,类似也可能会发生以下三种情况:

  • 如果该互斥量当前没有被其他线程锁住,则调用线程将该互斥量锁住,直到调用unlock之前,该线程一致拥有该锁。
  • 如果该互斥量已经被其他线程锁住,则try_lock调用返回false,当前的调用线程不会被阻塞。
  • 如果该互斥量被当前调用线程锁住,则会产生死锁(deadlock)。

  • recursive_mutex

recursive_mutex叫做递归互斥锁,该锁专门用于递归函数中的加锁操作。

  • 如果在递归函数中使用mutex互斥锁进行加锁,那么在线程进行递归调用时,可能会重复申请已经申请到但自己还未释放的锁,进而导致死锁问题。
  • recursive_mutex允许同一个线程对互斥量多次上锁(即递归上锁),来获得互斥量对象的多层所有权,但是释放互斥量时需要调用与该锁层次深度相同次数的unlock

除此之外,recursive_mutex也提供了lock、try_lockunlock成员函数,其的特性与mutex大致相同。

我们看到下面的代码能够保证线程在递归时也能一直占有锁,只有当递归完成才会释放锁,两个线程对全局变量进行递归++操作。

#include <iostream>
#include <thread>
#include <mutex>
std::recursive_mutex mtx;
int  x = 0;
void recursiveFunction(int count)
{
    mtx.lock();
    std::cout << "Thread " << std::this_thread::get_id() << ": Lock acquired, count = "
        << count << std::endl;
    if (count > 0) 
    {
        x++;
        recursiveFunction(count - 1);
    }
    std::cout << "Thread " << std::this_thread::get_id() << ": Lock released, count = " 
        << count << std::endl;
    mtx.unlock();
}
int main()
{
    std::thread t1(recursiveFunction, 3);
    std::thread t2(recursiveFunction, 2);
    t1.join();
    t2.join();
    cout << "------------------------------------------" << endl;
    cout << "final result: " << x << endl;
    return 0;
}


  • timed_mutex

timed_mutex中提供了以下两个成员函数:

  • try_lock_for:接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间之内还是没有获得锁),则返回false。
  • try_lock_untill:接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间点到来时还是没有获得锁),则返回false。
  • 除此之外,timed_mutex也提供了lock、try_lockunlock成员函数,其的特性与mutex相同。

利用时间锁可以写一些有趣的程序,下面的运行结果是不能确定的

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
std::timed_mutex mtx;
void fireworks() 
{
    // 等待获得锁 : 每个线程每200ms打印"-"
    while (!mtx.try_lock_for(std::chrono::milliseconds(200))) 
    {
        std::cout << "-";
    }
    // 得到一个锁! 等待1秒,然后这个线程打印"*"
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    std::cout << "*\n";
    mtx.unlock();
}
int main()
{
    std::thread threads[10];
    // 启动 10 个线程:
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(fireworks);
    // join 10个线程
    for (auto& th : threads) th.join();
    return 0;
}

  • std::recursive_timed_mutex

recursive_timed_mutex就是recursive_mutex和timed_mutex的结合,recursive_timed_mutex既支持在递归函数中进行加锁操作,也支持定时锁。


2、lock_guard和unique_lock

互斥锁的使用很简单,但是有些情况下互斥锁的使用可能会变得很棘手,例如:

  • 如果加锁的范围太大,那么极有可能在中途返回时忘记了解锁,那么以后其他线程申请这个互斥锁的就会被阻塞住,也就是造成了死锁问题。
  • 又或者是如果线程在锁的范围内抛异常,导致没有解锁,也很容易导致死锁问题。
#include <iostream>      
#include <thread>        
#include <mutex>
int x = 0;
mutex mtx;
void Func(int n)
{
  for (size_t i = 0; i < n; i++)
  {
    try
    {
      mtx.lock();
      ++x;
      cout << x << endl;
      if (rand() % 3 == 0)
      {
        throw exception("抛异常");
      }
      mtx.unlock();
    }
    catch (const std::exception& e)
    {
      cout << e.what() << endl;
    }
  }
}
int main()
{
  thread t1(Func, 10);
  thread t2(Func, 10);
  t1.join();
  t2.join();
  return 0;
}

为了解决上面的问题,C++11采用RAII的方式对锁进行了封装,于是就出现了lock_guardunique_lock


lock_guard

lock_guard是C++11中的一个模板类,其定义如下:

lock_guard类模板主要是通过RAII的方式,对其管理的互斥锁进行了封装。

  • 在需要加锁的地方,用互斥锁实例化一个lock_guard对象,在lock_guard的构造函数中会调用lock()进行加锁。
  • lock_guard对象出作用域前会调用析构函数,在lock_guard的析构函数中会调用unlock()自动解锁。
  • lock_guard对象定义到该对象析构,这段区域的代码都属于互斥锁的保护范围。
  • lock_guard类对象也是也是不支持拷贝的。

有了这种方法我们就不用害怕出现上面的情况了!

#include <iostream>              
#include <thread>     
#include <mutex>
int x = 0;
mutex mtx;
void Func(int n)
{
  for (size_t i = 0; i < n; i++)
  {
    try
    {
      lock_guard<mutex> lck(mtx);
      ++x;
      cout << x << endl;
      if (rand() % 3 == 0)
      {
        throw exception("抛异常");
      }
    }
    catch (const std::exception& e)
    {
      cout << e.what() << endl;
    }
  }
}
int main()
{
  thread t1(Func, 10);
  thread t2(Func, 10);
  t1.join();
  t2.join();
  return 0;
}

相关文章
|
19天前
|
数据采集 Java API
Jsoup库能处理多线程下载吗?
Jsoup库能处理多线程下载吗?
|
2月前
|
算法 C++ 容器
C++标准库(速查)总结
C++标准库(速查)总结
82 6
|
1月前
|
缓存 安全 C++
C++无锁队列:解锁多线程编程新境界
【10月更文挑战第27天】
51 7
|
1月前
|
消息中间件 存储 安全
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
58 1
|
2月前
|
存储 并行计算 安全
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛,常见场景包括并行计算、网络编程中的并发服务器和图形用户界面(GUI)应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计,以确保程序的正确性和稳定性。
|
2月前
|
存储 程序员 C++
C++常用基础知识—STL库(2)
C++常用基础知识—STL库(2)
82 5
|
2月前
|
存储 自然语言处理 程序员
C++常用基础知识—STL库(1)
C++常用基础知识—STL库(1)
74 1
|
2月前
|
存储 前端开发 C++
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
82 6
|
2月前
|
C++
C++ 多线程之线程管理函数
这篇文章介绍了C++中多线程编程的几个关键函数,包括获取线程ID的`get_id()`,延时函数`sleep_for()`,线程让步函数`yield()`,以及阻塞线程直到指定时间的`sleep_until()`。
41 0