【C++】多线程的用法（包含线程池小项目）

已于 2024-01-17 10:22:52 修改
阅读量842 收藏 4
点赞数 1
分类专栏： 编程学习 文章标签： c++ 开发语言
于 2023-09-13 11:45:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55252589/article/details/132843450
版权

一些小Tips: 

  • linux环境下，编译多线程程序时，需要加上后缀 -lpthread 引入线程库：
 g++ 7.thread_pool.cpp -lpthread
  • bash下查看一个可执行程序的运行时间：
time ./a.out
  •   需要引入的库函数有：
#include<thread> // 引入线程库
#include<mutex> // 加入锁机制需要引入库函数mutex
#include<condition_variable> // 引入信号量机制
  •  在C++程序中获得本进程的进程id：
this_thread::get_id()
  • 在C++程序中如何定义信号量、锁：
condition_variable m_cond    // 信号量
std::mutex m_mutex;          // 互斥锁，在非std命名空间的情况下
  • 一个线程的栈所占用的空间有多大？——8M。查看命令：
ulimit -a

多线程概念：

  • 进程是资源分配的最基本单位；线程是进程中的概念，是调度的基本单位，共享进程空间资源。
  • 什么是临界资源？——多线程情况下，大家都能访问到的资源。
  • 所谓的多线程只不过就是指定的某一个执行函数为入口函数的另外一套执行流程。

代码样例：

#include<iostream>
#include<thread>
using namespace std;

#define BEGINS(x) namespace x{   
#define ENDS(x) }

BEGINS(thread_usage)    // 自定义命名空间
void func() {
    cout << "hello wolrd" << endl;
    return ;
}
int main() {
    thread t1(func);  // t1已经开始运行了
    t1.join();        // 等待t1线程结束
    return 0;
}
ENDS(thread_usage)

int main() {
    thread_usage::main();     // 调用该命名空间下的main函数

    return 0;
}
  • 那么如何给入口函数传参呢？ 在C++中就很简单：
void print(int a, int b) {
    cout << a << " " << b << endl;
    return ;
}
int main() {
    thread t2(print, 3, 4);
    t2.join();
    return 0;
}

多线程设计理念：

  • 多线程封装思维：在相应的功能函数内部，不要去访问全局变量，类似于一个原子操作的功能。本身就支持多线程并行。
  • 多线程程序设计：线程功能函数和入口函数要分开。（高内聚低耦合）
  • 能不用锁就不用锁，因为这个锁机制会给程序运行效率带来极大的影响。

1. 多线程实现素数统计的功能

1.1. 不加锁版：

#include<iostream>
#include<thread>
#include<cmath>
#include<mutex>
using namespace std;

#define BEGINS(x) namespace x{
#define ENDS(x) }

BEGINS(is_prime)
bool is_prime(int x) {
    for (int i = 2, I = sqrt(x); i <= I; i++) {
        if (x % i == 0) return false;
    }
    return true;
}
// 多线程——功能函数 
int prime_count(int l, int r) {
    // 从l到r范围内素数的数量
    int ans = 0;
    for (int i = l; i <= r; i++) {
        ans += is_prime(i);
    }
    return ans;
}
// 多线程——入口函数 
void worker(int l, int r, int &ret) {
    cout << this_thread::get_id() << "begin" << endl;
    ret = prime_count(l, r);
    cout << this_thread::get_id() << "dnoe" << endl;
}
int main() {
    #define batch 500000
    thread *t[10];
    int ret[10];
    for (int i = 0, j = 1; i < 10; i++, j += batch) {
        t[i] = new thread(worker, j, j + batch - 1, ref(ret[i]));
    }
    for (auto x : t) x->join();
    int ans = 0;
    for (auto x : ret) ans += x;
    for (auto x : t) delete x;
    cout << ans << endl;
    #undef batch
    return 0;
}
ENDS(is_prime)

int main() {
    // thread_usage::main();
    is_prime::main();
    return 0;
}
  • 运行时间：总时长0.512s，系统时间0.02s，用户时间1.92s

1.2. 加锁版：

#include<iostream>
#include<thread>
#include<cmath>
#include<mutex>
using namespace std;

#define BEGINS(x) namespace x{
#define ENDS(x) }
BEGINS(prime_count2) 
int ans = 0;
std::mutex m_mutex;
bool is_prime(int x) {
    for (int i = 2, I = sqrt(x); i <= I; i++) {
        if (x % i == 0) return false;
    }
    return true;
}
void prime_count(int l, int r) {
    cout << this_thread::get_id() << " begin\n";
    for (int i = l; i <= r; i++) {
        std::unique_lock<std::mutex> lock(m_mutex); // 临界区
        ans += is_prime(i);
        lock.unlock();    
    }
    cout << this_thread::get_id() << " done\n";
    return ;
}
int main() {
    #define batch 500000
    thread *t[10];
    for (int i = 0, j = 1; i < 10; i++, j += batch) {
        t[i] = new thread(prime_count, j, j + batch - 1);
    }
    for (auto x : t) x->join();
    for (auto x : t) delete x;
    cout << ans << endl;
    #undef batch
    return 0;
}
ENDS(prime_count2)

int main() {
    prime_count2::main();
    return 0;
}
  • 运行时间：总时长5.916s，系统时间7.44s，用户时间6.50s

显然能够看出，加了锁要比不加锁耗时得多。所以加锁的行为要慎重。

1.3. 引入原子操作版：

  • 为什么不用++而是用+=：因为+=是原子操作，而++不是，所以++操作在多线程情况下可能存在覆盖写的问题。
  • 为什么使用__sync_fetch_and_add函数：因为这个函数也是原子操作。
#include<iostream>
#include<thread>
#include<cmath>
#include<mutex>
using namespace std;

#define BEGINS(x) namespace x{
#define ENDS(x) }

BEGINS(thread3)
int ans = 0;
bool is_prime(int x) {
    for (int i = 2, I = sqrt(x); i <= I; i++) {
        if (x % i == 0) return false;
    }
    return true;
}
void prime_count(int l, int r) {
    cout << this_thread::get_id() << "begin\n";
    for (int i = l; i <= r; i++) {
        int ret = is_prime(i);
        __sync_fetch_and_add(&ans, ret);
    }
    cout << this_thread::get_id() << "done\n";
}
int main() {
    #define batch 500000
    thread *t[10];
    for (int i = 0, j = 1; i < 10; i++, j += batch) {
        t[i] = new thread(prime_count, j, j + batch - 1);
    }
    for (auto x : t) x->join();
    for (auto x : t) delete x;
    cout << ans << endl;
    #undef batch 
    return 0;
}
ENDS(thread3)

int main() {
    thread3::main();
    return 0;
}

  • - `2.06s user`：表示程序在用户态消耗的CPU时间为2.06秒。这是程序执行期间用于执行用户代码的时间。
  • - `0.02s system`：表示程序在内核态消耗的CPU时间为0.02秒。这是程序执行期间用于执行内核代码的时间。
  • - `385% cpu`：表示程序使用了385%的CPU资源。这个值超过100%是因为程序可能在多个CPU核心上并行执行。所以 总时间 < 用户态+内核态时间 是非常正常的。
  • - `0.538 total`：表示程序从开始执行到结束的总时间为0.538秒。这是包括了实际执行时间、等待时间和其他非CPU消耗的时间。

2. 小项目：线程池的实现

  • 线程作为一种内存资源，在通常的多线程设计模式下，申请线程资源并不可控。而我们自然希望申请内存的动作是可控的。
  • 一个好的解决办法就是限制一个池子的大小来存放一些线程贯穿程序运行周期始终，也就是线程池。在线程池内部，线程数量是可控的。把一个个计算任务打包，扔到一个任务队列中，线程池中的线程争相从任务队列中领取任务并执行。这样就实现了资源的有效利用和管控。
  • 什么是计算任务？——分为过程（函数方法）和数据（函数参数）；
  • 如何进行打包——bind()方法。

代码实现：

/*************************************************************************
        > File Name: threadpool.cpp
        > Author: jby
        > Mail: 
        > Created Time: Wed 13 Sep 2023 08:48:23 AM CST
 ************************************************************************/

#include<iostream>
#include<cmath>
#include<vector>
#include<unordered_map>
#include<queue>
#include<mutex>
#include<thread>
#include<condition_variable>
#include<functional>
using namespace std;

#define BEGINS(x) namespace x {
#define ENDS(x) }

BEGINS(thread_pool_test)
class Task {
public:
    template<typename FUNC_T, typename ...ARGS>
    Task(FUNC_T func, ARGS ...args) {
        this->func = bind(func, forward<ARGS>(args)...);
    }
    void run() {
        func();
        return ;
    }
private:
    function<void()> func; // 任意函数
};
class ThreadPool {
public:
    ThreadPool(int n = 1) : thread_size(n), threads(n), starting(false) {
        this->start();
        return ;
    }
    void worker() {
        auto id = this_thread::get_id(); // 获得本进程号
        running[id] = true;
        while (running[id]) {
            // 取任务
            Task *t = get_task(); 
            t->run();
            delete t;
        }
        return ;
    }
    void start() {
        if (starting == true) return ; // 如果已经开始了就不用启动了
        for (int i = 0; i < thread_size; i++) {
            threads[i] = new thread(&ThreadPool::worker, this);
        }
        starting = true;
        return ;
    }
    template<typename FUNC_T, typename ...ARGS>
    void add_task(FUNC_T func, ARGS ...args) {
        unique_lock<mutex> lock(m_mutex); 
        tasks.push(new Task(func, forward<ARGS>(args)...)); // 任务池相当于临界资源
        m_cond.notify_one(); // 生产者消费者模型
        return ;
    }
    void stop() {
        if (starting == false) return ; // 如果已经关了就不用再关了
        for (int i = 0; i < threads.size(); i++) { // 往队列末尾投递毒药任务
            this->add_task(&ThreadPool::stop_runnnig, this);
        }
        for (int i = 0; i < threads.size(); i++) {
            threads[i]->join();
        }
        for (int i = 0; i < threads.size(); i++) {
            delete threads[i]; // 释放那片进程剩余的空间
            threads[i] = nullptr; // 进程指针指向空
        }
        starting = false;
        return ;
    }
    ~ThreadPool() {
        this->stop();
        while (!tasks.empty()) { // 如果任务队列里还有任务没执行完，全部丢弃
            delete tasks.front();
            tasks.pop();
        }
        return ;
    }
private:
    bool starting;
    int thread_size;
    Task *get_task() {
        unique_lock<mutex> lock(m_mutex);
        while (tasks.empty()) m_cond.wait(lock); // 生产者消费者模型 //子进程的中wait函数对互斥量进行解锁，同时线程进入阻塞或者等待状态。
        Task *t = tasks.front();
        tasks.pop();
        return t;
    }
    std::mutex m_mutex;
    std::condition_variable m_cond;
    vector<thread *> threads; // 线程池子
    unordered_map<decltype(this_thread::get_id()), bool> running; // 进程号到运行状态的哈希映射
    queue<Task *> tasks;  // 任务队列
    void stop_runnnig() { // 毒药任务
        auto id = this_thread::get_id();
        running[id] = false;
        return ;
    }
};
bool is_prime(int x) {
    for (int i = 2, I = sqrt(x); i <= I; i++) {
        if (x % i == 0) return false;
    }
    return true;
}
int prime_count(int l, int r) {
    int ans = 0;
    for (int i = l; i <= r; i++) {
        ans += is_prime(i);
    }
    return ans;
}
void worker(int l, int r, int &ret) {
    cout << this_thread::get_id() << "begin\n";
    ret = prime_count(l, r);
    cout << this_thread::get_id() << "done\n";
    return ;
}
int main() {
    #define batch 500000
    ThreadPool tp(5); // 五个任务的窗口队列
    int ret[10];
    for (int i = 0, j = 1; i < 10; i++, j += batch) {
        tp.add_task(worker, j, j + batch - 1, ref(ret[i]));
    }
    tp.stop();
    int ans = 0;
    for (auto x : ret) ans += x;
    cout << ans << endl;
    #undef batch
    return 0;
}
ENDS(thread_pool_test)

int main() {
    thread_pool_test::main();
    return 0;
}

一碗姜汤
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++ 线程池/Github 开源项目源码分析（progschj/ThreadPool）
为啥不吃肉捏 的博客
03-20 1132
维基百科上对线程池的简要介绍：线程池（thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。ThreadPool 项目地址是一个简易的基于 c++11 标准的线程池实现，采用了。
c++11多线程与线程池
weixin_34254823的博客
12-09 248
2019独角兽企业重金招聘Python工程师标准>>> ...
C++多线程编程-手写线程池
xiaoyou137的博客
02-14 554
需要使用支持C++17的编译器编译。
C++ 线程及线程池详解
yuyuyuj1e的博客
10-16 756
C++ 线程
C++中多线程的运用
siyi441的博客
02-21 330
构造函数thread()构造一个线程对象，没有关联任何线程函数，即没有启动任何线程构造一个线程对象，关联线程函数fn并传入参数args1、args2.....其他成员函数get_id()获取线程id常用用法为：获取当前进程id -- this_thread::get_id();jion()函数调用后会阻塞线程，当该线程结束后，主线程才会继续执行joinable()线程是否还在执行，joinable代表的是一个正在执行中的线程。detach()需要在创建后立马调用。
多线程处理百万级数据入库
weixin_45067120的博客
08-22 1803
1.创建线程类重写run方法 2.拆分List用线程池处理
C++实现线程池的简单方法示例
08-19
主要给大家介绍了关于C++实现线程池的简单方法，文中通过示例代码介绍的非常详细，对大家学习或者使用C++具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
C++11 简单实现线程池的方法
12-16
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在...
深入解析C++编程中线程池的使用
12-31
传 统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线程，由该线程执行任务。任务执行完毕后，线程退出，这就是是“即时创建，即 时销毁”的策略。尽管与创建进程相比，创建线程的时间...
基于C++11的threadpool线程池(简洁且可以带任意多的参数)
01-01
然而 c++ 对于多线程的支持还是比较低级，稍微高级一点的用法都需要自己去实现，譬如线程池、信号量等。线程池(thread pool)这个东西，在面试上多次被问到，一般的回答都是：“管理一个任务队列，一个线程队列，然后...
开源的win32平台c++多线程开发包
10-24
是用c++编写的开源的多线程开发包，用于win32平台，简单易用。
基于VS2010的C++多线程开发Demo
10-29
基于VS2010的C++多线程开发Demo 1.基于Dialog开发应用程序，包含全部工程。 2.包含2个独立线程，涵盖线程创建，收发信号，信号挂起，唤醒 3.界面操作，易于理解掌握。
c++11多线程
qq_45691226的博客
06-09 1288
文章目录线程创建线程基本用法互斥量条件变量异步操作 线程创建            使用std::thread创建线程,只需要提供函数或者仿函数即可,std::thread使用了可变参数模板,可以传递任意个参数函数参数,但是函数的返回值会被忽略            示例: #include <iost
C++多线程详细讲解
热门推荐
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
【C++】基础：多线程介绍与程序示例
DevFrank的博客
02-21 1831
多线程介绍与程序示例
C++多线程项目实战代码详解
weixin_43870074的博客
08-04 1295
Chapter-1-code1 #include "stdafx.h" #include <iostream> //_tmain 相当于main函数，argc,输入参数个数，argv[],参数列表 void _tmain(int argc, _TCHAR* argv[]) { std::cout << "Welcome C++ Multithreading CookBook!\t" << std::endl; system("pause"); } ...
C++多线程项目 - 进程间通信实现（一）
YJEthan的博客
10-13 1592
进程间通信的方式
c++多线程项目 - 认识线程
YJEthan的博客
10-20 493
线程创建、加入、分离、取消、退出
c++代码使用线程池的时候怎么保证多个线程按顺序执行
最新发布
09-18
### 回答1： ...综上所述，可以通过使用有序任务队列、固定线程数的线程池、阻塞队列以及Future和Callable等方式来保证多个线程按顺序执行。根据实际需求和具体情况，选择合适的方式来实现按顺序执行的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值