【Linux】写个日志和再谈线程池

2024-03-25 11:52
文章标签 linux 线程 日志 写个

本文主要是介绍【Linux】写个日志和再谈线程池，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在这里插入图片描述

欢迎来到Cefler的博客😁
🕌博客主页：折纸花满衣
🏠个人专栏：信号量和线程池

在这里插入图片描述

目录

  • 👉🏻日志代码
    • Log.cpp
    • Main.cc
  • 👉🏻线程池代码
    • LockGuard.hpp(自定义互斥锁，进行加锁和解锁)
    • Thread.hpp
    • Task.hpp(安排线程任务)
    • ThreadPool.hpp
  • 👉🏻读写锁和自旋锁
    • c++读写锁实现伪代码
    • c++自旋锁实现伪代码

👉🏻日志代码

Log.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once#include <iostream>
#include <fstream>
#include <string>
#include <cstdarg>
#include <ctime>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>using namespace std;
enum
{Debug = 0,Info,Warning,Error,Fatal
};enum
{Screen = 10,//向显示器OneFile,ClassFile
};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";}
}const int defaultstyle = Screen;
const std::string default_filename = "log.";
const std::string logdir = "log";class Log
{
public:Log() : style(defaultstyle), filename(default_filename){mkdir(logdir.c_str(), 0775);}void Enable(int sty) //{style = sty;}std::string TimeStampExLocalTime(){time_t currtime = time(nullptr);struct tm* curr = localtime(&currtime);char time_buffer[128];snprintf(time_buffer, sizeof(time_buffer), "%d-%d-%d %d:%d:%d",curr->tm_year + 1900, curr->tm_mon + 1, curr->tm_mday,curr->tm_hour, curr->tm_min, curr->tm_sec);return time_buffer;}void WriteLogToOneFile(const std::string& logname, const std::string& message){umask(0);int fd = open(logname.c_str(), O_CREAT | O_WRONLY | O_APPEND, 0666);if (fd < 0) return;write(fd, message.c_str(), message.size());close(fd);// std::ofstream out(logname);// if (!out.is_open())//     return;// out.write(message.c_str(), message.size());// out.close();}void WriteLogToClassFile(const std::string& levelstr, const std::string& message){std::string logname = logdir;logname += "/";logname += filename;logname += levelstr;WriteLogToOneFile(logname, message);}void WriteLog(const std::string& levelstr, const std::string& message){switch (style){case Screen:std::cout << message;break;case OneFile:WriteLogToClassFile("all", message);break;case ClassFile:WriteLogToClassFile(levelstr, message);break;default:break;}}void LogMessage(int level, const char* format, ...) // 类C的一个日志接口{char leftbuffer[1024];std::string levelstr = LevelToString(level);std::string currtime = TimeStampExLocalTime();std::string idstr = std::to_string(getpid());char rightbuffer[1024];va_list args; // char *, void *va_start(args, format);// args 指向了可变参数部分vsnprintf(rightbuffer, sizeof(rightbuffer), format, args);va_end(args); // args = nullptr;snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%s][%s] ",levelstr.c_str(), currtime.c_str(), idstr.c_str());std::string loginfo = leftbuffer;loginfo += rightbuffer;WriteLog(levelstr, loginfo);}// void operator()(int level, const char *format, ...)// {//     LogMessage(int level, const char *format, ...)// }~Log() {}private:int style;std::string filename;
};Log lg;class Conf
{
public:Conf(){lg.Enable(Screen);}~Conf(){}
};Conf conf;

Main.cc

#include <iostream>
#include "Log.hpp"int main()
{Log lg;lg.Enable(OneFile);lg.LogMessage(Debug, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Info, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Warning, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Error, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Fatal, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Debug, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Info, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Warning, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Error, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Fatal, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Debug, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Info, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Warning, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Error, "this is a log message: %d, %lf\n", 123, 3.14);lg.LogMessage(Fatal, "this is a log message: %d, %lf\n", 123, 3.14);return 0;
}

上述我们是将内容写进一个文件夹里lg.Enable(OneFile);
我们看结果：
在这里插入图片描述

👉🏻线程池代码

LockGuard.hpp(自定义互斥锁，进行加锁和解锁)

#pragma once#include <pthread.h>// 不定义锁，默认认为外部会给我们传入锁对象
class Mutex
{
public:Mutex(pthread_mutex_t *lock):_lock(lock){}void Lock(){pthread_mutex_lock(_lock);}void Unlock(){pthread_mutex_unlock(_lock);}~Mutex(){}private:pthread_mutex_t *_lock;
};class LockGuard
{
public:LockGuard(pthread_mutex_t *lock): _mutex(lock){_mutex.Lock();}~LockGuard(){_mutex.Unlock();}
private:Mutex _mutex;
};

Thread.hpp

#pragma once#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>// 设计方的视角
//typedef std::function<void()> func_t;
template<class T>
using func_t = std::function<void(T&)>;template<class T>
class Thread
{
public:Thread(const std::string &threadname, func_t<T> func, T &data):_tid(0), _threadname(threadname), _isrunning(false), _func(func), _data(data){}static void *ThreadRoutine(void *args) // 类内方法，{// (void)args; // 仅仅是为了防止编译器有告警Thread *ts = static_cast<Thread *>(args);ts->_func(ts->_data);return nullptr;}bool Start(){int n = pthread_create(&_tid, nullptr, ThreadRoutine, this/*?*/);if(n == 0) {_isrunning = true;return true;}else return false;}bool Join(){if(!_isrunning) return true;int n = pthread_join(_tid, nullptr);if(n == 0){_isrunning = false;return true;}return false;}std::string ThreadName(){return _threadname;}bool IsRunning(){return _isrunning;}~Thread(){}
private:pthread_t _tid;std::string _threadname;bool _isrunning;func_t<T> _func;T _data;
};

Task.hpp(安排线程任务)

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>const int defaultvalue = 0;enum
{ok = 0,div_zero,mod_zero,unknow
};const std::string opers = "+-*/%";class Task
{
public:Task(){}Task(int x, int y, char op): data_x(x), data_y(y), oper(op), result(defaultvalue), code(ok){}void Run(){switch (oper){case '+':result = data_x + data_y;break;case '-':result = data_x - data_y;break;case '*':result = data_x * data_y;break;case '/':{if (data_y == 0)code = div_zero;elseresult = data_x / data_y;}break;case '%':{if (data_y == 0)code = mod_zero;elseresult = data_x % data_y;}break;default:code = unknow;break;}}void operator()(){Run();}std::string PrintTask(){std::string s;s = std::to_string(data_x);s += oper;s += std::to_string(data_y);s += "=?";return s;}std::string PrintResult(){std::string s;s = std::to_string(data_x);s += oper;s += std::to_string(data_y);s += "=";s += std::to_string(result);s += " [";s += std::to_string(code);s += "]";return s;}~Task(){}private:int data_x;int data_y;char oper; // + - * / %int result;int code; // 结果码，0: 结果可信 !0: 结果不可信，1,2,3,4
};

ThreadPool.hpp

#pragma once#include <iostream>
#include <queue>
#include <vector>
#include <pthread.h>
#include <functional>
#include "Log.hpp"
#include "Thread.hpp"
#include "LockGuard.hpp"static const int defaultnum = 5;class ThreadData
{
public:ThreadData(const std::string &name) : threadname(name){}~ThreadData(){}public:std::string threadname;
};template <class T>
class ThreadPool
{
private:ThreadPool(int thread_num = defaultnum) : _thread_num(thread_num){pthread_mutex_init(&_mutex, nullptr);//互斥锁初始化pthread_cond_init(&_cond, nullptr);//条件变量初始化// 构建指定个数的线程for (int i = 0; i < _thread_num; i++){// 待优化std::string threadname = "thread-";threadname += std::to_string(i + 1);ThreadData td(threadname);// Thread<ThreadData> t(threadname,//                      std::bind(&ThreadPool<T>::ThreadRun, this, std::placeholders::_1), td);// _threads.push_back(t);_threads.emplace_back(threadname,std::bind(&ThreadPool<T>::ThreadRun, this,std::placeholders::_1),td);//emplace_back函数直接在容器的末尾就地构造一个新的元素(直接构造)，而不是先创建一个临时对象lg.LogMessage(Info, "%s is created...\n", threadname.c_str());//打印日志}}ThreadPool(const ThreadPool<T> &tp) = delete;const ThreadPool<T> &operator=(const ThreadPool<T>) = delete;public:// 有线程安全问题的(单例模式-懒汉模式):在懒汉模式下，单例实例在第一次使用时才被创建//线程不安全是因为会有多个线程进行创建实例static ThreadPool<T> *GetInstance(){if (instance == nullptr){LockGuard lockguard(&sig_lock);//为了规避线程不安全情况，要进行加锁操作if (instance == nullptr){lg.LogMessage(Info, "创建单例成功...\n");instance = new ThreadPool<T>();}}return instance;}bool Start(){// 启动for (auto &thread : _threads){thread.Start();lg.LogMessage(Info, "%s is running ...\n", thread.ThreadName().c_str());}return true;}void ThreadWait(const ThreadData &td)//线程等待{lg.LogMessage(Debug, "no task, %s is sleeping...\n", td.threadname.c_str());pthread_cond_wait(&_cond, &_mutex);}void ThreadWakeup()//唤醒线程{pthread_cond_signal(&_cond);}void checkSelf(){// 1. _task_num > _task_num_high_water && _thread_num < _thread_num_high_water// 创建更多的线程，并且更新_thread_num// 2. _task_num == _task_num_low_water && _thread_num >= _thread_num_high_water// 把自己退出了，并且更新_thread_num}void ThreadRun(ThreadData &td)//线程执行{while (true){// checkSelf()checkSelf();// 取任务T t;{LockGuard lockguard(&_mutex);while (_q.empty()){ThreadWait(td);//执行队列如果为空，则让当前线程进行等待lg.LogMessage(Debug, "thread %s is wakeup\n", td.threadname.c_str());//若执行到这一步，说明线程以及被唤醒}t = _q.front();_q.pop();}// 处理任务t();lg.LogMessage(Debug, "%s handler task %s done, result is : %s\n",td.threadname, t.PrintTask().c_str(), t.PrintResult().c_str());}}void Push(T &in){lg.LogMessage(Debug, "other thread push a task, task is : %s\n", in.PrintTask().c_str());LockGuard lockguard(&_mutex);_q.push(in);ThreadWakeup();}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}// for debugvoid Wait(){for (auto &thread : _threads){thread.Join();}}private:std::queue<T> _q;std::vector<Thread<ThreadData>> _threads;int _thread_num;pthread_mutex_t _mutex;pthread_cond_t _cond;static ThreadPool<T> *instance;static pthread_mutex_t sig_lock;// 扩展1：// int _thread_num;// int _task_num;// int _thread_num_low_water;  // 3// int _thread_num_high_water; // 10// int _task_num_low_water;    // 0// int _task_num_high_water;   // 30// 扩展2: 多进程+多线程// int number{1};
};template <class T>
ThreadPool<T> *ThreadPool<T>::instance = nullptr;
template <class T>
pthread_mutex_t ThreadPool<T>::sig_lock = PTHREAD_MUTEX_INITIALIZER;

👉🏻读写锁和自旋锁

当多个线程尝试同时访问共享资源时，为了保证数据的一致性，需要使用锁来实现同步。读加锁和自旋锁都是常见的锁机制，用于控制对共享资源的访问。

  1. 读加锁（Read Lock）：

    • 读加锁允许多个线程同时对共享资源进行读取操作，但不允许写操作。
    • 当一个线程获取了读锁后，其他线程可以继续获取读锁，但不能获取写锁，直到所有的读锁都被释放。
    • 读锁之间不会互斥，可以同时存在多个读锁。
    • 读锁适用于读操作频繁，写操作较少的场景，可以提高并发读取效率。

  2. 自旋锁（Spin Lock）：

    • 自旋锁是一种忙等待的锁机制，当一个线程尝试获取锁时，如果锁已经被其他线程占用，该线程会循环检测锁是否被释放，而不是进入睡眠状态。
    • 自旋锁适用于对共享资源的访问时间非常短的情况，避免了线程频繁切换和上下文切换的开销。
    • 自旋锁在多核处理器上效果更好，因为在等待锁的过程中可以利用处理器时间进行自旋操作，提高效率。

总的来说，读加锁适合读操作频繁的场景，而自旋锁适合对共享资源访问时间短、线程并发量不高的场景。选择合适的锁机制可以提高程序的并发性能和效率。

c++读写锁实现伪代码

读写锁（Read-Write Lock）是一种多线程同步机制，允许多个线程同时对共享资源进行读取操作，但在进行写操作时需要互斥排他。它的设计目的是在读操作频繁、写操作较少的场景下提高并发性能。

读写锁通常包括两种状态：读模式和写模式。

  • 读模式：多个线程可以同时获取读锁，以便并发地读取共享资源。
  • 写模式：当一个线程获取写锁时，其他线程无法同时获取读锁或写锁，确保写操作的互斥性。

与互斥锁不同，读写锁允许多个线程同时持有读锁，这样可以提高并发性能。只有当有线程持有写锁时，其他线程才不能获取读锁或写锁。

读写锁的使用场景通常是在数据的读操作远远多于写操作的情况下，通过允许并发读取来提高性能。然而，如果写操作频繁，读写锁可能会失去优势，因为写操作会阻塞所有的读操作。

在C++中，可以使用 std::shared_mutex 来实现读写锁的功能，通过 lock_shared() 获取读锁，通过 lock() 获取写锁，实现对共享资源的安全访问。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;
int sharedData = 0;void writer() {mtx.lock(); // 加锁sharedData++; // 写操作std::cout << "Writer updated data to: " << sharedData << std::endl;mtx.unlock(); // 解锁
}int main() {std::thread writerThread1(writer);std::thread writerThread2(writer);writerThread1.join();writerThread2.join();return 0;
}

c++自旋锁实现伪代码

C++11 提供的原子操作来实现自旋锁

#include <atomic>class SpinLock {
public:void lock() {while (locked.test_and_set(std::memory_order_acquire)) {// 自旋等待锁释放}}void unlock() {locked.clear(std::memory_order_release);}private:std::atomic_flag locked = ATOMIC_FLAG_INIT;
};

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注🌹🌹🌹❤️ 🧡 💛,学海无涯苦作舟,愿与君一起共勉成长

在这里插入图片描述
在这里插入图片描述

这篇关于【Linux】写个日志和再谈线程池的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/844929。

相关文章

Linux内核的调试（TODO）

Linux内核的调试（TODO）

（TODO）
阅读更多...
linux-基础知识3

linux-基础知识3

打包和压缩 zip 安装zip软件包 yum -y install zip unzip 压缩打包命令: zip -q -r -d -u 压缩包文件名 目录和文件名列表 -q:不显示命令执行过程-r:递归处理，打包各级子目录和文件-u:把文件增加/替换到压缩包中-d:从压缩包中删除指定的文件 解压:unzip 压缩包名 打包文件 把压缩包从服务器下载到本地 把压缩包上传到服务器(zip
阅读更多...
Linux 网络编程 --- 应用层

Linux 网络编程 --- 应用层

一、自定义协议和序列化反序列化 代码： 序列化反序列化实现网络版本计算器 二、HTTP协议 1、谈两个简单的预备知识 https://www.baidu.com/ --- 域名 --- 域名解析 --- IP地址 http的端口号为80端口，https的端口号为443 url为统一资源定位符。CSDNhttps://mp.csdn.net/mp_blog/creation/editor
阅读更多...
【Python编程】Linux创建虚拟环境并配置与notebook相连接

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如，在当前目录下创建一个名为 myenv 的虚拟环境： python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行： source myenv/bin/activate 3.与notebook连接 在虚拟环境中，使用 pip 安装 Jupyter 和 ipykernel： pip instal
阅读更多...
Linux_kernel驱动开发11

Linux_kernel驱动开发11

一、改回nfs方式挂载根文件系统         在产品将要上线之前，需要制作不同类型格式的根文件系统         在产品研发阶段，我们还是需要使用nfs的方式挂载根文件系统         优点：可以直接在上位机中修改文件系统内容，延长EMMC的寿命         【1】重启上位机nfs服务         sudo service nfs-kernel-server resta
阅读更多...
【Linux 从基础到进阶】Ansible自动化运维工具使用

【Linux 从基础到进阶】Ansible自动化运维工具使用

Ansible自动化运维工具使用 Ansible 是一款开源的自动化运维工具，采用无代理架构（agentless），基于 SSH 连接进行管理，具有简单易用、灵活强大、可扩展性高等特点。它广泛用于服务器管理、应用部署、配置管理等任务。本文将介绍 Ansible 的安装、基本使用方法及一些实际运维场景中的应用，旨在帮助运维人员快速上手并熟练运用 Ansible。 1. Ansible的核心概念
阅读更多...
Linux服务器Java启动脚本

Linux服务器Java启动脚本

Linux服务器Java启动脚本 1、初版2、优化版本3、常用脚本仓库 本文章介绍了如何在Linux服务器上执行Java并启动jar包， 通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动， 那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。 1、初版 第一个版本是常用的做法，直接使用nohup后台启动jar包， 并将日志输出到当前文件夹n
阅读更多...
[Linux]：进程(下)

[Linux]：进程(下)

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：Linux学习 贝蒂的主页：Betty’s blog 1. 进程终止 1.1 进程退出的场景 进程退出只有以下三种情况： 代码运行完毕，结果正确。代码运行完毕，结果不正确。代码异常终止（进程崩溃）。 1.2 进程退出码 在编程中，我们通常认为main函数是代码的入口，但实际上它只是用户级
阅读更多...
flume系列之：查看flume系统日志、查看统计flume日志类型、查看flume日志

flume系列之：查看flume系统日志、查看统计flume日志类型、查看flume日志

遍历指定目录下多个文件查找指定内容 服务器系统日志会记录flume相关日志 cat /var/log/messages |grep -i oom 查找系统日志中关于flume的指定日志 import osdef search_string_in_files(directory, search_string):count = 0
阅读更多...
我在移动打工的日志

我在移动打工的日志

客户：给我搞一下录音 我：不会。不在服务范围。 客户：是不想吧 我：笑嘻嘻（气笑） 客户：小姑娘明明会，却欺负老人 我：笑嘻嘻 客户：那我交话费 我：手机号 客户：给我搞录音 我：不会。不懂。没搞过。 客户：那我交话费 我：手机号。这是电信的啊！！我这是中国移动！！ 客户：我不管，我要充话费，充话费是你们的 我：可是这是移动！！中国移动！！ 客户：我这是手机号 我：那又如何，这是移动！你是电信！！
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2