【Linux】多线程_9

news2024/9/21 20:46:05

文章目录

  • 九、多线程
    • 10. 线程池
  • 未完待续

九、多线程

10. 线程池

这里我没实现一些 懒汉单例模式 的线程池，并且包含 日志打印 的线程池：
Makefile：

threadpool:Main.cc
	g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -f threadpool

Thread.hpp：

#ifndef __THREAD_HPP__
#define __THREAD_HPP__

#include <iostream>
#include <string>
#include <unistd.h>
#include <functional>
#include <pthread.h>

namespace ThreadModule
{
    // 类型别名
    using func_t = std::function<void(std::string)>;

    // 线程类
    class Thread
    {
    public:
        void Excute()
        {
            _func(_threadname);
        }
    public:
        Thread(func_t func, std::string name = "none-name")
            :_func(func)
            ,_threadname(name)
            ,_stop(true)
        {}

        // 执行任务
        static void *threadroutine(void *args)
        {
            Thread *self = static_cast<Thread*>(args);
            self->Excute();
            return nullptr;
        }

        // 启动线程
        bool Start()
        {
            int n = pthread_create(&_tid, nullptr, threadroutine, this);
            if(!n)
            {
                _stop = false;
                return true;
            }
            else
            {
                return false;
            }
        }

        // 停止线程
        void Detach()
        {
            if(!_stop)
            {
                pthread_detach(_tid);
            }
        }

        // 等待线程结束
        void Join()
        {
            if(!_stop)
            {
                pthread_join(_tid, nullptr);
            }
        }

        std::string name()
        {
            return _threadname;
        }

        void Stop()
        {
            _stop = true;
        }

        ~Thread()
        {}
    private:
        pthread_t _tid;
        std::string _threadname;
        func_t _func;
        bool _stop;
    };
}

#endif

LockGuard.hpp：

#ifndef __LOCK_GUARD_HPP__
#define __LOCK_GUARD_HPP__

#include <iostream>
#include <pthread.h>

class LockGuard
{
public:
    // 构造函数加锁
    LockGuard(pthread_mutex_t *mutex)
        :_mutex(mutex)
    {
        pthread_mutex_lock(_mutex);
    }

    // 析构函数解锁
    ~LockGuard()
    {
        pthread_mutex_unlock(_mutex);
    }
private:
    pthread_mutex_t *_mutex;
};

#endif

Log.hpp：

#pragma once

#include <iostream>
#include <fstream>
#include <cstdio>
#include <string>
#include <ctime>
#include <cstdarg>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include "LockGuard.hpp"

// 宏定义，用于定义日志格式
#define LOG(level, format, ...) do{LogMessage(__FILE__, __LINE__, gIsSave, level, format, ##__VA_ARGS__);}while (0)
// 将日志输入到文件
#define EnableFile() do{gIsSave = true;}while (0)
// 将日志输出到显示器
#define EnableScreen() do{gIsSave = false;}while (0)

bool gIsSave = false;
// 日志文件名
const std::string logname = "log.txt";

// 枚举日志级别
enum Level
{
    DEBUG = 0,
    INFO,
    WARNING,
    ERROR,
    FATAL
};

// 保存日志到文件
void SaveFile(const std::string &filename, const std::string &message)
{
    std::ofstream out(filename, std::ios::app);
    if (!out.is_open())
    {
        return;
    }
    out << message;
    out.close();
}

// 日志级别转字符串
std::string LevelToString(int level)
{
    switch (level)
    {
    case DEBUG:
        return "Debug";
    case INFO:
        return "Info";
    case WARNING:
        return "Warning";
    case ERROR:
        return "Error";
    case FATAL:
        return "Fatal";
    default:
        return "Unknown";
    }
}

// 获取当前时间字符串
std::string GetTimeString()
{
    time_t curr_time = time(nullptr);
    struct tm *format_time = localtime(&curr_time);
    if (format_time == nullptr)
        return "None";
    char time_buffer[1024];
    snprintf(time_buffer, sizeof(time_buffer), "%d-%d-%d %d:%d:%d",
             format_time->tm_year + 1900,
             format_time->tm_mon + 1,
             format_time->tm_mday,
             format_time->tm_hour,
             format_time->tm_min,
             format_time->tm_sec);
    return time_buffer;
}

// 日志锁，同一时刻只能写一个日志
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

// 日志信息
void LogMessage(std::string filename, int line, bool issave, int level, const char *format, ...)
{
    // 日志级别
    std::string levelstr = LevelToString(level);
    // 时间
    std::string timestr = GetTimeString();
    // 进程id
    pid_t selfid = getpid();

    // 日志内容
    char buffer[1024];
    va_list arg;
    va_start(arg, format);
    vsnprintf(buffer, sizeof(buffer), format, arg);
    va_end(arg);

    // 日志格式化
    std::string message = "[" + timestr + "]" + "[" + levelstr + "]" +
                          "[" + std::to_string(selfid) + "]" +
                          "[" + filename + "]" + "[" + std::to_string(line) + "] " + buffer + "\n";
    LockGuard lockguard(&lock);

    // 输出日志
    if (!issave)
    {
        std::cout << message;
    }
    else
    {
        SaveFile(logname, message);
    }
}

Task.hpp：

#pragma once

#include <iostream>
#include <string>
#include <functional>

class Task
{
public:
    Task()
    {}

    Task(int a, int b)
        :_a(a)
        ,_b(b)
        ,_result(0)
    {}

    // 执行加法功能
    void Excute()
    {
        _result = _a + _b;
    }

    // 结果
    std::string ResultToString()
    {
        return std::to_string(_a) + "+" + std::to_string(_b) + "=" + std::to_string(_result);
    }

    // 问题
    std::string DebugToString()
    {
        return std::to_string(_a) + "+" + std::to_string(_b) + "= ?";
    }

    // 重载（）运算符
    void operator()()
    {
        Excute();
    }
private:
    int _a;
    int _b;
    int _result;
};

ThreadPool.hpp：

#pragma once

#include <iostream>
#include <vector>
#include <queue>
#include <pthread.h>
#include "Log.hpp"
#include "Thread.hpp"
#include "LockGuard.hpp"

using namespace ThreadModule;

// 线程池默认线程数
const static int gdefaultthreadnum = 10;

template <typename T>
class ThreadPool
{
private:
    // 线程互斥锁
    void LockQueue()
    {
        pthread_mutex_lock(&_mutex);
    }

    // 线程互斥解锁
    void UnlockQueue()
    {
        pthread_mutex_unlock(&_mutex);
    }

    // 线程等待
    void ThreadSleep()
    {
        pthread_cond_wait(&_cond, &_mutex);
    }

    // 线程唤醒
    void ThreadWakeup()
    {
        pthread_cond_signal(&_cond);
    }

    // 唤醒全部线程
    void ThreadWakeupAll()
    {
        pthread_cond_broadcast(&_cond);
    }

    // 私有构造函数
    ThreadPool(int threadnum = gdefaultthreadnum)
        :_threadnum(threadnum)
        ,_waitnum(0)
        ,_isrunning(false)
    {
        // 初始化锁
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);
        // 日志
        LOG(INFO, "ThreadPool Construct()");
    }

    // 初始化线程池
    void InitThreadPool()
    {
        // 创建一批线程
        for (int num = 0; num < _threadnum; num++)
        {
            std::string name = "thread-" + std::to_string(num + 1);
            _threads.emplace_back(std::bind(&ThreadPool::HandlerTask, this, std::placeholders::_1), name);
            // 日志
            LOG(INFO, "init thread %s done", name.c_str());
        }
        _isrunning = true;
    }

    // 启动线程池
    void Start()
    {
        for (auto &thread : _threads)
        {
            thread.Start();
        }
    }

    // 任务处理函数
    void HandlerTask(std::string name) // 类的成员方法，也可以成为另一个类的回调方法，方便我们继续类级别的互相调用！
    {
        // 日志
        LOG(INFO, "%s is running...", name.c_str());
        while (true)
        {
            // 加锁
            LockQueue();
            while (_task_queue.empty() && _isrunning)
            {
                _waitnum++;
                ThreadSleep();
                _waitnum--;
            }
            // 退出情况
            if (_task_queue.empty() && !_isrunning)
            {
                UnlockQueue();
                break;
            }
            // 取出任务
            T t = _task_queue.front();
            _task_queue.pop();
            UnlockQueue();
            // 日志
            LOG(DEBUG, "%s get a task", name.c_str());
            // 执行任务
            t();
            // 日志
            LOG(DEBUG, "%s handler a task, result is: %s", name.c_str(), t.ResultToString().c_str());
        }
    }

    // 禁用拷贝构造和赋值操作
    ThreadPool<T> &operator=(const ThreadPool<T> &) = delete;
    ThreadPool(const ThreadPool<T> &) = delete;
public:
    static ThreadPool<T> *GetInstance()
    {
        // 首次使用时，创建线程池单例
        if (nullptr == _instance)
        {
            // 对于多线程创建单例时加锁，保证线程安全
            LockGuard lockguard(&_lock);
            if (nullptr == _instance)
            {
                // 创建线程池实例
                _instance = new ThreadPool<T>();
                _instance->InitThreadPool();
                _instance->Start();
                LOG(DEBUG, "创建线程池单例");
                return _instance;
            }
        }
        // 已经创建过线程池单例，直接返回
        LOG(DEBUG, "获取线程池单例");
        return _instance;
    }

    // 停止线程池
    void Stop()
    {
        LockQueue();
        _isrunning = false;
        ThreadWakeupAll();
        UnlockQueue();
    }
    
    // 等待线程池退出
    void Wait()
    {
        for (auto &thread : _threads)
        {
            thread.Join();
            LOG(INFO, "%s is quit...", thread.name().c_str());
        }
    }

    // 向线程池中添加任务
    bool Enqueue(const T &t)
    {
        bool ret = false;
        LockQueue();
        if (_isrunning)
        {
            _task_queue.push(t);
            if (_waitnum > 0)
            {
                ThreadWakeup();
            }
            LOG(DEBUG, "enqueue task success");
            ret = true;
        }
        UnlockQueue();
        return ret;
    }
    
    // 析构自动释放锁资源
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }
private:
    // 线程池中线程个数
    int _threadnum;
    // 线程
    std::vector<Thread> _threads;
    // 任务队列
    std::queue<T> _task_queue;
    // 互斥锁
    pthread_mutex_t _mutex;
    // 条件变量
    pthread_cond_t _cond;

    // 等待线程数
    int _waitnum;
    // 线程池是否运行
    bool _isrunning;

    // 线程池单例
    static ThreadPool<T> *_instance;
    // 全局锁
    static pthread_mutex_t _lock;
};

// 初始化静态变量
template <typename T>
ThreadPool<T> *ThreadPool<T>::_instance = nullptr;

// 全局锁
template <typename T>
pthread_mutex_t ThreadPool<T>::_lock = PTHREAD_MUTEX_INITIALIZER;

Main.cc：

#include "ThreadPool.hpp"
#include "Task.hpp"
#include "Log.hpp"
#include <iostream>
#include <string>
#include <memory>
#include <ctime>

int main()
{
    // 日志
    LOG(DEBUG, "程序已经加载");
    sleep(2);
    // 创建线程池单例
    ThreadPool<Task>::GetInstance();
    sleep(2);
    // 获取单例
    ThreadPool<Task>::GetInstance();
    sleep(2);

    ThreadPool<Task>::GetInstance();
    sleep(2);

    ThreadPool<Task>::GetInstance();
    sleep(2);

    // 等待线程结束
    ThreadPool<Task>::GetInstance()->Wait();
    sleep(2);

    return 0;
}

结果演示：
在这里插入图片描述

未完待续

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1930518.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

前端开发常用命令行工具及操作命令（Node.js 和 npm、Yarn、vue、React、Git、Webpack）

前端开发常用命令行工具及操作命令（Node.js 和 npm、Yarn、vue、React、Git、Webpack）

在前端开发中&#xff0c;掌握常用的命令行工具和命令可以大大提高开发效率。接下来将介绍一些常用的前端命令行工具和命令&#xff0c;涵盖从项目初始化到构建和部署的各个环节。 1. Node.js 和 npm 安装 Node.js 和 npm 首先&#xff0c;需要安装 Node.js。安装 Node.js 时…
阅读更多...
FreeRTOS的中断管理、临界资源保护、任务调度

FreeRTOS的中断管理、临界资源保护、任务调度

什么是中断&#xff1f; 简介&#xff1a;让CPU打断正常运行的程序&#xff0c;转而去处理紧急的事件&#xff08;程序&#xff09;&#xff0c;就叫中断。 中断优先级分组设置 ARM Cortex-M 使用了 8 位宽的寄存器来配置中断的优先等级&#xff0c;这个寄存器就是中断优先级…
阅读更多...
硅纪元视角 | 微软开发全新AI模型，革新电子表格处理效率！

硅纪元视角 | 微软开发全新AI模型，革新电子表格处理效率！

在数字化浪潮的推动下&#xff0c;人工智能&#xff08;AI&#xff09;正成为塑造未来的关键力量。硅纪元视角栏目紧跟AI科技的最新发展&#xff0c;捕捉行业动态&#xff1b;提供深入的新闻解读&#xff0c;助您洞悉技术背后的逻辑&#xff1b;汇聚行业专家的见解&#xff0c;…
阅读更多...
在ArcGIS Pro中新建空图层的最快方法

在ArcGIS Pro中新建空图层的最快方法

01常规方法 一般情况下&#xff0c;如果我们想新建一个要素图层&#xff0c;常规方法是&#xff1a; 在目录框中&#xff0c;找一个gdb数据库&#xff0c;右键——新建——要素类&#xff1a; 设置好各种属性&#xff1a; 创建结果如下&#xff1a; 最后将要素类拖入地图中即…
阅读更多...
openeuler 终端中文显示乱码、linux vim中文乱码

openeuler 终端中文显示乱码、linux vim中文乱码

1、解决终端乱码 网上很多教程试了都不生效&#xff0c;以下方法有效&#xff1a; 确认终端支持中文显示&#xff1a; echo $LANG 输出应该包含 UTF-8&#xff0c;例如 en_US.UTF-8。如果不是&#xff0c;您可以通过以下命令设置为 UTF-8&#xff1a; export LANGzh_CN.UTF-8…
阅读更多...
Rust RefCell＜T＞ 和内部可变性模式

Rust RefCell＜T＞ 和内部可变性模式

内部可变性&#xff08;Interior mutability&#xff09;是 Rust 中的一个设计模式&#xff0c;它允许你即使在有不可变引用时也可以改变数据&#xff0c;这通常是借用规则所不允许的。为了改变数据&#xff0c;该模式在数据结构中使用 unsafe 代码来模糊 Rust 通常的可变性和借…
阅读更多...
阿里云CDN- https（设计支付宝春节开奖业务）

阿里云CDN- https（设计支付宝春节开奖业务）

HTTP相关概念 1. HTTP概述 http是最广泛的网络协议&#xff0c;是客户端与服务器之间的请求与应答的标准&#xff08;TCP&#xff09;&#xff0c;用于www服务器传输超文本到本地浏览器的传输协议&#xff0c;使浏览器更加高效&#xff0c;网络传输减少。 2.HTTPS概述 http…
阅读更多...
【总结】实际业务场景中锁、事务、异常如何考虑使用？

【总结】实际业务场景中锁、事务、异常如何考虑使用？

文章目录 锁处理目的&#xff1a;考虑锁控制思路&#xff1a;生命周期接口并发控制解决方案&#xff1a;测试锁是否生效&#xff1a;模拟多线程并发场景的2种方式&#xff1a; 事务处理目的&#xff1a;考虑事务控制思路&#xff1a;解决方案&#xff1a; 总结 锁处理 目的&am…
阅读更多...
集群架构-web服务器（接入负载均衡+数据库+会话保持redis）--15454核心配置详解

集群架构-web服务器（接入负载均衡+数据库+会话保持redis）--15454核心配置详解

紧接着前面的集群架构深化—中小型公司&#xff08;拓展到大型公司业务&#xff09;–下面图简单回顾一下之前做的及故障核心知识总结&#xff08;等后期完全整理后&#xff0c;上传资源希望能帮大家&#xff09; web集群架构-接入负载均衡部署web02服务器等 web集群-搭建web0…
阅读更多...
[C++]一些list,stack和queue选择题和编程题

[C++]一些list,stack和queue选择题和编程题

这时我们学完后的应用 一、选择题 1.下面有关vector和list的区别&#xff0c;描述错误的是( ) A.vector拥有一段连续的内存空间&#xff0c;因此支持随机存取&#xff0c;如果需要高效的随机存取,应该使用vector B.list拥有一段不连续的内存空间&#xff0c;如果需要大量的插入…
阅读更多...
JavaScript基础(十四)

JavaScript基础(十四)

函数 很多人一看到这两个字就头大&#xff0c;可能由于多年被数学摧残有不小阴影&#xff0c;放心&#xff0c;我们这里的函数不是那些东西&#xff0c;在编程中我们的函数指的是: 程序的基本单元&#xff0c;是完成特定任务的代码语句块。 我们在写程序时&#xff0c;可能会…
阅读更多...
【RAG探索第4讲】KG+RAG丨基于知识图谱优化大型语言模型方法

【RAG探索第4讲】KG+RAG丨基于知识图谱优化大型语言模型方法

原文链接&#xff1a;【RAG探索第4讲】KGRAG丨基于生物医学知识图谱优化的大型语言模型提示生成方法 一、现有问题&#xff1a; LLMs在处理特定领域或高度专业化查询时缺乏专业知识&#xff0c;导致回答不够准确和可靠。 LLMs可能会产生事实错误&#xff08;即幻觉&#xff0…
阅读更多...
【整洁单元测试】测试气味Test Smells

【整洁单元测试】测试气味Test Smells

背景 "Code smell" 是软件开发中的一个术语&#xff0c;指的是代码中可能表明存在问题的某些迹象或模式。这些迹象本身并不表示代码一定有错误&#xff0c;但它们通常表明代码可能难以理解、维护或扩展。Code smells 可以视为一种警告&#xff0c;提示开发者需要进一…
阅读更多...
0基础学python-14：python进阶之面向对象

0基础学python-14：python进阶之面向对象

前言 Python是一门解释型、面向对象以及动态数据类型的高级程序设计语言&#xff0c;今天所要说的就是极为重要的概念&#xff0c;面向对象。 一、面向对象的核心概念&#xff1a; 1.类&#xff08;Class&#xff09;&#xff1a; 类是对象的抽象描述&#xff0c;是面向对象编…
阅读更多...
HarmonyOS开发中几个常见问题

HarmonyOS开发中几个常见问题

前言 最近开始HarmonyOS应用开发&#xff0c;遇到一些小问题&#xff0c;也算是自己看官网文档没记住的东西&#xff0c;过程中再记录一下。 一、更改应用的名字和图标 对比看下Android工程中是如何更改的&#xff0c;只需要在清单文件AndroidManifest.xml中&#xff0c;更改…
阅读更多...
机器学习 | 深入理解激活函数

机器学习 | 深入理解激活函数

什么是激活函数&#xff1f; 在人工神经网络中&#xff0c;节点的激活函数定义了该节点或神经元对于给定输入或一组输入的输出。然后&#xff0c;将此输出用作下一个节点的输入&#xff0c;依此类推&#xff0c;直到找到原始问题的所需解决方案。 它将结果值映射到所需的范围…
阅读更多...
CSS综合案例（快报模块头部制作）

CSS综合案例（快报模块头部制作）

&#xff08;大家好&#xff0c;今天我们将继续来学习CSS的相关知识&#xff0c;大家可以在评论区进行互动答疑哦~加油&#xff01;&#x1f495;&#xff09; 目录 一、前述 二、案例分析 1.样例参看 2.拆分分析 三、案例实施 一、前述 案例&#xff1a;快报模块头部制…
阅读更多...
微信小程序基本语法

微信小程序基本语法

官网 https://developers.weixin.qq.com/miniprogram/dev/framework/ 视频教程&#xff1a;尚硅谷微信小程序开发教程&#xff0c;2024最新微信小程序项目实战&#xff01; 仿慕尚花坊项目源码&#xff1a;https://gitee.com/abcdfdewrw/flower-workshop 目录 一&#xff0c;初…
阅读更多...
热门软件缺陷管理工具2024：专业评测与建议

热门软件缺陷管理工具2024：专业评测与建议

国内外主流的10款软件缺陷管理工具软件对比&#xff1a;PingCode、Worktile、禅道、Tapd、Teambition、Tower、JIRA、Bugzilla、MantisBT、Trac。 在软件开发过程中&#xff0c;管理缺陷和漏洞常常成为一项挑战&#xff0c;尤其是在项目规模庞大时。选择一个高效的软件缺陷管理…
阅读更多...
C#实现自定义标签的设计和打印

C#实现自定义标签的设计和打印

背景：最近在进行资产盘点的时候，需要对固定资产设计标签并进行打印。 设计标签：选用的是Fastreport自带的，可拆包忌用的标签设计器；进行标签的模型设计。 软件解压后可直接进行使用。模板的设计基本都是无脑操作，拖拽控件按，放置到固定未知即可；我设计的模板如下： 说…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023