C++ 多线程系统编程入门

最新推荐文章于 2023-07-19 00:34:37 发布
最新推荐文章于 2023-07-19 00:34:37 发布
阅读量590 收藏 6
点赞数
分类专栏： 多线程 文章标签： 多线程

引言

在 C++11 发布之前，Linux程序员都用过Pthread来实现多线程，但有了C++ 11 的std::thread以后，便可以在语言层面编写多线程程序，直接的好处就是多线程程序的可移植性得到了很大的提高。

另外，在开发C++程序时，一般在吞吐量、并发、实时性上有较高的要求。在语言层面上实现的多线程，也可以实现从并发、异步、缓存 方面的性能的提高。

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

  • <thread>: 主要声明了std::thread类，另外std::this_thread命名空间也在该头文件中
  • <mutex>: 主要声明了与互斥量(mutex)相关的类，包括std::mutex系列类，std::lock_guard，std::unique_lock，以及其它的类型和函数

线程的创建

在每个c++应用程序中，都有一个默认的主线程，即main函数，在c++11中，我们可以通过创建std::thread类的对象来创建其他线程，每个std :: thread对象都可以与一个线程相关联，只需包含头文件< thread>。可以使用std :: thread对象附加一个回调，当这个新线程启动时，它将被执行。 这些回调可以为 函数指针、函数对象、Lambda函数。 

线程对象可通过std::thread thObj(< CALLBACK>)来创建，新线程将在创建新对象后立即开始，并且将与已启动的线程并行执行传递的回调。此外，任何线程可以通过在该线程的对象上调用join()函数来等待所创建的新线程退出。 

1.使用函数指针创建新线程

#include <iostream>
#include <thread>

void thread_function() {
    for (int i = 0; i < 5; i++)
        std::cout << "thread function excuting" << std::endl;
}

int main() {
    std::thread threadObj(thread_function);    //创建threadObj线程对象并绑定thread_function函数
    for (int i = 0; i < 5; i++)
        std::cout << "Display from MainThread" << std::endl;
    threadObj.join();                          //等待threadObj线程结束
    std::cout << "Exit of Main function" << std::endl;
    return 0;
}

2.使用函数对象创建线程

#include <iostream>
#include <thread>

class DisplayThread {
public:
    void operator ()() {
        for (int i = 0; i < 100; i++)
            std::cout << "Display Thread Excecuting" << std::endl;
    }
};

int main() {
    std::thread threadObj((DisplayThread()));        //创建threadObj线程对象并绑定DisplayThread函数对象
    for (int i = 0; i < 100; i++)
        std::cout << "Display From Main Thread " << std::endl;
    std::cout << "Waiting For Thread to complete" << std::endl;
    threadObj.join();
    std::cout << "Exiting from Main Thread" << std::endl;

    return 0;
}

每个std::thread对象都有一个相关联的id，std::thread::get_id() —-成员函数中给出对应线程对象的id; 
std::this_thread::get_id()—-给出当前线程的id，如果std::thread对象没有关联的线程，get_id()将返回默认构造的std::thread::id对象：“not any thread”，std::thread::id也可以表示id。

线程的 join 和 detach

启动了线程，你需要明确是要等待线程结束(加入式)，还是让其自主运行(分离式)，一个是通过调用std::thread对象上调用join()函数等待这个线程执行完毕：

std::thread threadObj(funcPtr); 
threadObj.join();

例如，主线程启动10个线程，启动完毕后，main函数等待他们执行完毕，join完所有线程后，main函数继续执行：

#include <iostream>
#include <thread>
#include <algorithm>

class WorkerThread
{
public:
    void operator()(){
        std::cout<<"Worker Thread "<<std::this_thread::get_id()<<"is Excecuting"<<std::endl;
    }
};

int main(){
    std::vector<std::thread> threadList;
    for(int i = 0; i < 10; i++){
        threadList.push_back(std::thread(WorkerThread()));
    }
    // 等待所有 worker thread 线程运行完毕 i.e.
    // 为每个 thread 对象调用 join() function
    std::cout<<"Wait for all the worker thread to finish"<<std::endl;
    std::for_each(threadList.begin(), threadList.end(), std::mem_fn(&std::thread::join));
    std::cout<<"Exiting from Main Thread"<<std::endl;

    return 0;
}

另一个是detach可以将线程与线程对象分离，让线程作为后台线程执行，当前线程也不会阻塞了。但是detach之后就无法再和线程发生联系了，如果线程执行函数使用了临时变量可能会出现问题，线程调用了detach在后台运行，临时变量可能已经销毁，那么线程会访问已经被销毁的变量：

std::thread threadObj(funcPtr)
threadObj.detach();

线程的参数传递

要将参数传递给线程的可关联对象或函数，只需将参数传递给std::thread构造函数，默认情况下，所有的参数都将复制到新线程的内部存储中。 

给线程传递参数：

#include <iostream>
#include <string>
#include <thread>

void threadCallback(int x, std::string str) {
  std::cout << "Passed Number = " << x << std::endl;
  std::cout << "Passed String = " << str << std::endl;
}
int main() {
  int x = 10;
  std::string str = "Sample String";
  std::thread threadObj(threadCallback, x, str);
  threadObj.join();
  return 0;
}

给线程传递引用：

#include <iostream>
#include <thread>

void threadCallback(const int & x) {
  int& y = const_cast<int&>(x);
  y++;
  std::cout << "Inside Thread x = " << x << std::endl;
}

int main() {
  int x = 9;
  std::cout << "In Main Thread : Before Thread Start x = " << x << std::endl;
  std::thread threadObj(threadCallback, x);
  threadObj.join();
  std::cout << "In Main Thread : After Thread Joins x = " << x << std::endl;
  return 0;
}

输出结果为： 


　　即使threadCallback接受参数作为引用，但是并没有改变main中x的值，在线程外引用是不可见的。这是因为线程函数threadCallback中的x是引用复制在新线程的堆栈中的临时值，使用 std::ref 可进行修改 std::thread threadObj(threadCallback, std::ref(x))。

指定一个类的成员函数的指针作为线程函数，将指针传递给成员函数作为回调函数，并将指针指向对象作为第二个参数：

#include <iostream>
#include <thread>

class DummyClass {
 public:
  DummyClass() { }
  DummyClass(const DummyClass& obj) { }
  void sampleMemberfunction(int x) {
    std::cout << "Inside sampleMemberfunction " << x << std::endl;
  }
};

int main() {
  DummyClass dummyObj;
  int x = 10;
  std::thread threadObj(&DummyClass::sampleMemberfunction, &dummyObj, x);
    // 此处类的成员函数的指针作为线程函数，必须使用 "&" 来创建指向成员的指针
  threadObj.join();

  return 0;
}

 

使用 Mutex 保护多线程的共享数据

　为了处理多线程环境中的竞争条件，我们需要mutex互斥锁，在修改或读取共享数据前，需要对数据加锁，修改完成后，对数据进行解锁。在c++11的线程库中，mutex在< mutex >头文件中，表示互斥体的类是std::mutex。

在下面的例子中，Wallet类提供了在Wallet中增加money的方法，并且在不同的线程中使用相同的Wallet对象，所以我们需要对Wallet的addMoney()方法加锁。在增加Wallet中的money前加锁，并且在离开该函数前解锁：Wallet类内部维护money，并提供函数addMoney()，这个成员函数首先获取一个锁，然后给wallet对象的money增加指定的数额，最后释放锁。

 

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

class Wallet {
    int mMoney;
    std::mutex mutex;
public:
    Wallet() : mMoney(0) { }
    int getMoney() { return mMoney;}
    void addMoney(int money) {
        mutex.lock();
        for (int i = 0; i < money; i++) {
            mMoney++;
        }
        mutex.unlock();
    }
};

int testMultithreadWallet() {
    Wallet walletObject;
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 1000));
        // 使用类方法作为创建进程的参数时，必须将方法名和对象加上引用
    }

    for (int i = 0; i < threads.size(); i++) {
        threads.at(i).join();
    }

    return walletObject.getMoney();
}

int main() {
    int val = 0;
    for (int k = 0; k < 1000; k++) {
        if ((val = testMultithreadWallet()) != 5000) {
            std::cout << "Error at count= " << k << " money in wallet" << val << std::endl;
        }
    }

    return 0;
}

使用std::lock_guard：这种情况保证了钱包里的钱不会出现少于5000的情况，因为addMoney()中的互斥锁确保了只有在一个线程修改完成money后，另一个线程才能对其进行修改，但是，如果我们忘记在函数结束后对锁进行释放会怎么样？这种情况下，一个线程将退出而不释放锁，其他线程将保持等待，为了避免这种情况，我们应当使用std::lock_guard，这是一个template class，它为mutex实现RALL，它将mutex包裹在其对象内，并将附加的mutex锁定在其构造函数中，当其析构函数被调用时，它将释放互斥体。

class Wallet {
  int mMoney;
  std::mutex mutex;
 public:
  Wallet() : mMoney(0) { }
  int getMoney() { return mMoney;}
  void addMoney(int money) {
    std::lock_guard<std::mutex> lockGuard(mutex);

    for (int i = 0; i < mMoney; ++i) {
      //如果在此处发生异常，lockGuadr的析构函数将会因为堆栈展开而被调用
      mMoney++;
      //一旦函数退出，那么lockGuard对象的析构函数将被调用，在析构函数中mutex会被释放
    }
  }
};

只能用 mutex.lock() 保护以 join() 方式处理的多线程的共享数据，对 detach() 方式处理的多线程，因为detach之后实现了线程分离，后台运行，无法再和其他线程发生联系了。

条件变量

  • 条件变量阻塞一个或多个线程，直到收到另外一个线程发来的通知或者超时，才会唤醒当前阻塞的进程，条件变量需要和互斥量配合使用。
  • C++11提供了两种条件变量
  1. std::condition_variable，配合std::unique_lock进行wait操作
  2. std::condition_variable_any，和任意带有lock，unlock的mutex进行搭配使用，比较灵活但效率略低。
  • 条件变量的使用过程如下:
  1. 拥有条件变量的线程获取互斥锁
  2. 循环检查某个条件，如果条件不满足，则阻塞直到条件满足，如果条件满足，则向下执行
  3. 某个线程满足条件执行完之后，调用notify_one或notify_all唤醒一个或者所有的等待线程

条件变量是一种用于在2个线程之间进行通信的事件，一个线程可以等待它得到信号，其他的线程可以给它发信号。在c++11中，条件变量需要头文件< condition_variable >，同时，条件变量还需要一个mutex锁。 
　　条件变量是如何运行的： 
　　·线程1调用等待条件变量，内部获取mutex互斥锁并检查是否满足条件； 
　　·如果没有，则释放锁，并等待条件变量得到发出的信号(线程被阻塞)，条件变量的wait()函数以原子方式提供这两个操作； 
　　·另一个线程，如线程2，当满足条件时，向条件变量发信号； 
　　·一旦线程1正等待其恢复的条件变量发出信号，线程1便获取互斥锁，并检查与条件变量相关关联的条件是否满足，或者是否是一个上级调用，如果多个线程正在等待，那么notify_one将只解锁一个线程； 
　　·如果是一个上级调用，那么它再次调用wait()函数。 
　　条件变量的主要成员函数： 
Wait() 
它使得当前线程阻塞，直到条件变量得到信号或发生虚假唤醒； 
它原子性地释放附加的mutex，阻塞当前线程，并将其添加到等待当前条件变量对象的线程列表中，当某线程在同样的条件变量上调用notify_one() 或者 notify_all()，线程将被解除阻塞； 
这种行为也可能是虚假的，因此，解除阻塞后，需要再次检查条件； 
一个回调函数会传给该函数，调用它来检查其是否是虚假调用，还是确实满足了真实条件； 
当线程解除阻塞后，wait()函数获取mutex锁，并检查条件是否满足，如果条件不满足，则再次原子性地释放附加的mutex，阻塞当前线程，并将其添加到等待当前条件变量对象的线程列表中。 
notify_one() 
如果所有线程都在等待相同的条件变量对象，那么notify_one会取消阻塞其中一个等待线程。 
notify_all() 
如果所有线程都在等待相同的条件变量对象，那么notify_all会取消阻塞所有的等待线程。

#include <iostream>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>
using namespace std::placeholders;

class Application {
    std::mutex m_mutex;
    std::condition_variable m_condVar;
    bool m_bDataLoaded;
public:
    Application() {
        m_bDataLoaded = false;
    }

    void loadData() {
        //使该线程sleep 1秒
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        std::cout << "Loading Data from XML" << std::endl;

        //锁定数据
        std::lock_guard<std::mutex> guard(m_mutex);

        //flag设为true，表明数据已加载
        m_bDataLoaded = true;

        //通知条件变量
        m_condVar.notify_one();
    }

    bool isDataLoaded() {
        return m_bDataLoaded;
    }

    void mainTask() {
        std::cout << "Do some handshaking" << std::endl;

        //获取锁
        std::unique_lock<std::mutex> mlock(m_mutex);

        //开始等待条件变量得到信号
        //wait()将在内部释放锁，并使线程阻塞
        //一旦条件变量发出信号，则恢复线程并再次获取锁
        //然后检测条件是否满足，如果条件满足，则继续，否则再次进入wait
        m_condVar.wait(mlock, std::bind(&Application::isDataLoaded, this));
        std::cout << "Do Processing On loaded Data" << std::endl;
    }
};

int main() {
    Application app;
    std::thread thread_1(&Application::mainTask, &app);
    std::thread thread_2(&Application::loadData, &app);
    thread_2.join();
    thread_1.join();

    return 0;
}


--------------------- 
作者：krais24 
来源：CSDN 
原文：https://blog.csdn.net/krais_wk/article/details/81095899 
版权声明：本文为博主原创文章，转载请附上博文链接！

SimonxxSun
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++线程数量的限制
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-20 2067
限制 线程的数量取决于线程栈空间的大小（可以使用ulimit -s查看栈空间大小） 132位Linux下（可以使用getconf LONG_BIT查看当前CPU运行在多少位的模式下），用户空间是3G，因此可创建的线程数量为3G/stack_size，但是理论上除了栈空间每个线程还有线程控制块的开销，所以实际值会小一些 修改限制 •使用ulimit -s 新栈空间大小修改默认栈空间大小 1.可以在/etc/rc.local 内 加入 ulimit -s 新栈空间大小 则可以开机就设置栈空间大小 •通过/etc
C++多线程编程入门
01-12
学习C++多线程，C++多线程编程入门！
C++并发编程——在运行时选择线程数量
让我思考一下
07-31 7518
在编写多线程程序时，运行多少线程比较合适呢？线程并不是越多越好，理论上，硬件支持多少线程数，就开多少个线程比较合适，有的比如完成端口IOCP中建议开2倍线程数，因为考虑到有些线程可能会挂起等情况。但最重要的一条，首先要获取当前硬件支持的线程数，通常情况下为CPU核数。std::thread::hardware_concurrency(); //获取当前CPU核心数量代码示例： 以下代码为st
c语言实现主线程创建10个子线程，每个子线程不断+1，直到1000
weixin_44056971的博客
07-25 973
面试被问到：c/c++语言实现主线程创建10个子线程，每个子线程不断+1，直到1000 #include <pthread.h> #include <cstdio> //#include "sem.hpp" #include <assert.h> pthread_mutex_t mutex; int number = 0; //sem mysem; //sem_t mysem; void *worker(void* arg){ while(true){
17_juc
海涛帅帅的博客
09-14 407
Java JUC简介 在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。 volatile关键字-内存可见性 概述 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态，需要确保当一个
C++多线程编程
sinat_31425585的博客
06-19 3214
C++多线程用法
C++多线程编程入门教程
08-10
C++多线程编程入门教程，讲解了多线程的概念，并且给出了linux和windows平台下多线程实现的例子。。
c++多线程编程
09-18
本文简介了pthread的用法，介绍了多核多线程编程的入门知识
C++ 多线程编程
梦心之魂的博客
07-19 2162
C++11之前，window和linux平台分别有各自的多线程标准，使用C++编写的多线程往往是依赖于特定平台的。Window平台提供用于多线程创建和管理的win32 api；Linux下则有POSIX多线程标准，Threads或Pthreads库提供的API可以在类Unix上运行；在C++11新标准中，可以简单通过使用thread库，来管理多线程。thread库可以看做对不同平台多线程API的一层包装；因此使用新标准提供的线程库编写的程序是跨平台的。
两种 C++ 多线程编程方式，看完不懂打我...
热门推荐
人人都懂物联网
11-30 2万+
多线程在实际编程中的重要性不言而喻，对 C++ 而言，当我们需要使用多线程时，有多种方案可供选择。比如 POSIX 线程 pthread、boost::thread 库、C++11 开始支持的 std::thread 库，以及其他一些第三方库 libdispatch（GCD）和 OpenMP 等等。 至于选择哪种多线程编程方案，需要根据你的实际项目、运行平台、团队协作等因素来考虑。一般而言，如果使用的是 Linux 操作系统，那么可以直接使用系统提供的 pthread 库编写多线程 C++ 程序；如果需要跨
C++之多线程编程
m0_67793822的博客
03-16 7300
一、并发的实现 1.多进程并发主要解决进程间通信的问题 ①同一电脑上：管道、文件、消息队列、内存共享。 ②不同电脑上：socket网络通信。 2. 单进程中的多个线程并发（一个主线程+多个子线程实现并发） ①一个进程中的所有线程共享内存空间 eg：全局变量，指针引用 二、线程的多种创建方式 1. 调用thread类去创建一个线程对象 ...
C++多线程编程（真实入门）
hanxiaoyong_的博客
01-06 2004
https://blog.csdn.net/Kprogram/article/details/89472995
C++多线程编程深度解析
xueyukun1的博客
03-16 4174
线程是轻量级的进程，一个进程中的线程共享地址空间，全局变量、全局内存、全局引用都可以在线程之间传递，所以多线程的开销远远小于多进程
CC++ 多线程编程
m7789456的博客
07-03 494
这些参数均为传入的参数，其中buf为你需要传递的数据的起始地址，比如你要传递一个数组A，长度是5，则buf为数组A的首地址。datatype为变量类型，注意该位置的变量类型是MPI预定义的变量类型，比如需要传递的是C++的int型，则在此处需要传入的参数是MPI_INT，其余同理。在C和C++中，status的变量类型为MPI_Status，分别有三个域，可以通过status.MPI_SOURCE，status.MPI_TAG和status.MPI_ERROR的方式调用这三个信息。
linux 多线程服务端编程:使用 muduo c++ 网络库》pdf
最新发布
07-26
2. 多线程编程的基础知识：介绍了多线程编程的基本概念和相关的线程同步和互斥机制，如互斥锁、条件变量等。并讲解了如何正确地使用这些机制，以保证多线程程序的正确性和高效性。 3. muduo C++网络库的使用：详细...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值