从零开始自制实现WebServer（五）---- 浅沿芳草鲜花小路静心踱步拨云见雾终见多线程ThreadPool

文章目录

全流程实现博客链接
前引
（五）---- 浅沿芳草鲜花小路静心踱步拨云见雾终见多线程ThreadPool
- 1、理清头绪直通主路抓住重点
- 2、罗列代码一回生二回熟再次起航
- - 1、echo.h
  - 1、echo.cc
  - 2、tcpserver.h
  - 2、tcpserver.cc
  - 3、acceptor.h
  - 3、acceptor.cc
  - 4、channel.h
  - 4、channel.cc
  - 5、tcpconnectionptr.h
  - 5、tcpconnectionptr.cc
  - 6、eventloop.h
  - 6、eventloop.cc
  - 7、epoller.h
  - 7、epoller.cc
  - 8、eventloopthreadpool.h（新增文件）
  - 8、eventloopthreadpool.cc（新增文件）
  - 9、eventloopthread.h（新增文件）
  - 9、eventloopthread.cc（新增文件）
  - 10、thread.h（新增文件）
  - 10、thread.cc（新增文件）
- 3、其他组件（Address、Callback、Mutex、Condition、makefile等等）
- - 1、address.h
  - 2、callback.h
  - 3、mutex.h（新增文件）
  - 4、condition.h（新增文件）
  - 5、latch.h（新增文件）
  - 6、makefile（注意链接 -lpthread）
- 4、tiny_muduo echo(One Loop Per Thread + Thread Pool 默认8线程) test
结束语

全流程实现博客链接

从零开始自制实现C++ High-Performance WebServer 全流程记录（基于muduo网络库）

前引

哎刚刚真的太难绷了家人们
之前同班同学在想如何在c++课堂上的随机30秒问答题拿高分把综测弄高一点
就找上了我让我有题看到了就来做做
本着好心想着能帮兄弟一把是一把反正也无所谓自然也就答应了下来
如果有题目来了就可以发消息给我我马上看了来做 30秒钟我还需要马上打开手机马上点进在线课堂然后浏览题目选完后跟同学发消息什么答案
结果刚刚发生了一件事情太难让我绷住了
一道理论题复制构造函数的形式是什么
四个选项看到题目我在脑海中疯狂搜索什么是复制构造函数我怎么不知道一点印象都没有然后就说了一个A 结果答案是C

然后对此我那位好兄弟就对我进行了一番点评部分截图如下实在是让我羞愧难当狡辩都没办法狡辩在回复消息的时候我确实真的还不知道什么是复制构造函数… 最恐怖的是我脑子里面真的一点这个函数的印象都没有

于是刚刚我实在找不到借口了我的同学还说全班的这道题目都对了就我一个人错了天啦。。我还在想怎么用c++实现一个线程安全的tiny_muduo 由此来实现一个高性能的多线程服务器结果被锐评了一番

我想了想是不是自己基础不扎实不过关呢但是说真的再怎么不过关也不至于我不知道这个概念吧复制构造函数究竟是什么我真的不知道然后我就去百度了一下结果如下

哎竟然是我天天都在写的熟悉的不能再熟悉的拷贝构造函数。。。我没想到拷贝构造函数的别名alias竟然是复制构造函数… 可能是业内拷贝构造函数说的太多了而且我对此印象太深刻了但是我是真的不知道有复制构造函数这种说法

心中千万个草泥马飞过去很无奈哈哈
这件事也就且当一门趣事给大家分享一下也就是刚刚发生的
再附一张我和那位好兄弟之间的聊天截图吧希望以后不要再在我身上发生这样的囧事了哈哈

（五）---- 浅沿芳草鲜花小路静心踱步拨云见雾终见多线程ThreadPool

我又取了这样哈哈很有意境的标题
《浅沿芳草鲜花小路静心踱步拨云见雾终见多线程ThreadPool》读完我甚至都想来加一句 Skr~ 静心踱步 ThreadPool 还押韵了哈哈

尽管呢现在我还没有拿起我的小白纸去研究EventLoopThreadPool 但是呢哈哈就是想来写一些博客没别的多的想法

最上面的那段话是我第二天来编辑的按照以往的性格我应该就把上面的那段话给删掉了但现在想了想也觉得还是很搞笑算了就留着吧哈哈

刚刚又忍不住去看了看书每当看了几页这本《linux多线程服务端编程》总觉得自己啥都不会 … 而且会被马上打乱现在已经有的头绪
其实现在的建议就是多看源码源码为主书籍为辅先不管三七二十一把源码看懂很多地方摸棱两可的也无所谓我觉得真的到看书的那一步是真的等差不多把一个有很多地方有缺陷有疑惑的服务器做出来了再去在书中找答案哈哈想到作为一名初学者看到这样的书籍的时候很难不会觉得头脑昏胀头晕目眩

此时如果各位读者看到这段话基本上一个有着到差不差的框架的muduo了哈哈不容易啊但是不好的消息是什么身体抱恙了可能是这段时间温差太大了或者是自己衣服穿的稍微有点少又或者是自己没怎么休息好反正就身体不是那么好然后昨天重感冒了今天晚上待会把博客发了就回寝室休息去了各位在学习生活的日子里面无论如何还是把身体放在第一位吧

1、理清头绪直通主路抓住重点

到了ThreadPool部分了其实也就是分析一下相较于之前的单线程的Reactor需要添加什么文件

1、EventLoopThreadPool 总的线程池 TcpServer连接新连接交互就是与总的线程池相沟通
2、EventLoopThread 封装线程一些与线程相关的成员以及做到EventLoopThreadPool 与Thread 信息传递的一些作用
3、Thread 最基类的成员线程类被EventLoopThread包装
4、MutexLock Condition Latch 互斥锁、条件变量、屏障前两个就不介绍了屏障主要是同步父子进程间的执行进度（互斥锁、条件变量的封装类）

其实主要添加的也就这么几个文件然后再去添加一些EventLoop TcpServer的函数这个大概我也就花了不到一天的时间也就完成了工作这段时间人身体不是很好效率比较低一天左右也就完成了

理清了之后然后我又去看了遍源码大概又去理了一下思路后又独自去写代码了
这次进度相较于第一次就快了相当的多了后面代码调试也是没调一会就好了发现自己条件变量、互斥量还不怎么会用对于一些线程间通信原语还不太熟又去补了补知识查了查博客看了看书再加上这边自己调试自然而然也就好了

然后这里基本上也就采用了RAII 很多细节的地方确实想不到想了半天还是不知道怎么实现的时候只能重新返回去看源码然后再返回来写
调试的过程没有用之前做CSAPP所用的gdb调试法还是用的和之前做操作系统的时候最简单最熟练的调试方法 printf + 不断地修改 make 运行然后看一下程序卡在了哪里

基本上也就是这些了对于之后怎么处理肯定是在重新读几遍这本书里面很多细节比如线程为什么有冲突怎么合理的解决对了这次没有处理内存所以里面是涉及大量的内存泄露的基本上析构函数都是没有写的

后面的基本上也就是在这个基础上不断地修改不断地完善然后把最终的一个健壮的网络库写出来其实也就是我写这些博客的最终目的啦

这一篇的代码没有处理内存只管分配不管释放基本运行正确也就算成功了好了先写到这里

这里相较于第一个版本顺带再把有一个类名之前取错了之后打算再改了 TcpConnectionPtr改成TcpConnection 在这里我就不改了感冒了不是很舒服现在也没有改想早点回去休息了改的话又要去改各种头文件还有makefile也要改估计改下来又要花一点时间这个任务就留在下篇吧

2、罗列代码一回生二回熟再次起航

这次默认是8线程的 thread pool + one loop per thread
相较于之前也算是阶段性的胜利了哈哈

1、echo.h

#ifndef TINY_MUDUO_ECHO_H_
#define TINY_MUDUO_ECHO_H_#include <stdio.h>#include <string>#include "tcpserver.h"
#include "tcpconnectionptr.h"static const int thread_nums = 8;namespace tiny_muduo {class Address;class EventLoop;}class EchoServer {public:EchoServer(tiny_muduo::EventLoop* loop, const tiny_muduo::Address& listen_addr);~EchoServer() {}void Start() {server_.Start();}void ConnectionCallback(tiny_muduo::TcpConnectionPtr* connection_ptr) {printf("echo_server has a new connection \n");  }void MessageCallback(tiny_muduo::TcpConnectionPtr* connection_ptr) {std::string message(connection_ptr->Get());printf("echo_server get message \n");connection_ptr->Send(message);}private:tiny_muduo::EventLoop* loop_;tiny_muduo::TcpServer server_;
};
#endif

1、echo.cc

#include "echo.h"#include "tcpserver.h"EchoServer::EchoServer(tiny_muduo::EventLoop* loop, const tiny_muduo::Address& listen_addr): loop_(loop),server_(loop, listen_addr) {server_.SetConnectionCallback(std::bind(&EchoServer::ConnectionCallback, this, _1));server_.SetMessageCallback(std::bind(&EchoServer::MessageCallback, this, _1));server_.SetThreadNums(thread_nums);
}

2、tcpserver.h

#ifndef TINY_MUDUO_TCPSERVER_H_
#define TINY_MUDUO_TCPSERVER_H_#include "callback.h"
#include "eventloop.h"
#include "acceptor.h"
#include "eventloopthreadpool.h"namespace tiny_muduo {class Address;class TcpServer {public:TcpServer(EventLoop* loop, const Address& address);~TcpServer();void Start() {threads_->StartLoop();loop_->RunOneFunc(std::bind(&Acceptor::Listen, acceptor_));}void SetConnectionCallback(const ConnectionCallback& callback) { connection_callback_ = callback;}void SetMessageCallback(const MessageCallback& callback) {message_callback_ = callback;}void SetThreadNums(int thread_nums) {threads_->SetThreadNums(thread_nums);    }void NewConnection(int connfd);private:EventLoop* loop_;EventLoopThreadPool* threads_;Acceptor* acceptor_;ConnectionCallback connection_callback_;MessageCallback message_callback_;
};}// namespace tiny_muduo
#endif

2、tcpserver.cc

#include "tcpserver.h"#include "eventloopthreadpool.h"
#include "acceptor.h"
#include "tcpconnectionptr.h"using namespace tiny_muduo;TcpServer::TcpServer(EventLoop* loop, const Address& address): loop_(loop),threads_(new EventLoopThreadPool(loop_)),acceptor_(new Acceptor(loop, address)) {acceptor_->SetNewConnectionCallback(std::bind(&TcpServer::NewConnection, this, _1));
}TcpServer::~TcpServer() {delete threads_;delete acceptor_;
}void TcpServer::NewConnection(int connfd) {EventLoop* loop = threads_->NextLoop(); printf("TcpServer NewConnection Arrive Tid:%ld Manage\n", loop->DebugShowTid());TcpConnectionPtr* ptr = new TcpConnectionPtr(loop, connfd);ptr->SetConnectionCallback(connection_callback_);ptr->SetMessageCallback(message_callback_);loop->RunOneFunc(std::bind(&TcpConnectionPtr::ConnectionEstablished, ptr));
}

3、acceptor.h

#ifndef TINY_MUDUO_ACCEPTOR_H_
#define TINY_MUDUO_ACCEPTOR_H_#include <functional>namespace tiny_muduo {class EventLoop;
class Address;
class Channel;class Acceptor {public:typedef std::function<void (int)> NewConnectionCallback;Acceptor(EventLoop* loop, const Address& address);void BindListenFd(const Address& address); void Listen();void NewConnection();void SetNewConnectionCallback(const NewConnectionCallback& callback) {new_connection_callback_ = callback;}private:EventLoop* loop_;int listenfd_;Channel* channel_;NewConnectionCallback new_connection_callback_;
};}
#endif

3、acceptor.cc

#include "acceptor.h"#include <assert.h>
#include <cstring>
#include <sys/socket.h>
#include <sys/types.h>
#include <bits/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>#include <functional>#include "address.h"
#include "channel.h"using namespace tiny_muduo;namespace {const int kMaxListenNum = 5;
}Acceptor::Acceptor(EventLoop* loop, const Address& address): loop_(loop),listenfd_(socket(PF_INET, SOCK_STREAM, 0)),channel_(new Channel(loop, listenfd_)) {BindListenFd(address);channel_->SetReadCallback(std::bind(&Acceptor::NewConnection, this));
}void Acceptor::BindListenFd(const Address& addr) {struct sockaddr_in address;memset(&address, 0, sizeof(address));address.sin_family = AF_INET;address.sin_port = htons(addr.port());inet_pton(AF_INET, addr.ip(), &address.sin_addr); int ret = bind(listenfd_, (struct sockaddr*)(&address), sizeof(address));assert(ret != -1);
}void Acceptor::Listen() {int ret = listen(listenfd_, kMaxListenNum);assert(ret != -1);channel_->EnableReading();
}void Acceptor::NewConnection() {struct sockaddr_in client;socklen_t client_addrlength = sizeof( client );int connfd = accept(listenfd_, (struct sockaddr*)&client, &client_addrlength);new_connection_callback_(connfd);
}

4、channel.h

#ifndef TINY_MUDUO_CHANNEL_H_
#define TINY_MUDUO_CHANNEL_H_#include <sys/epoll.h>#include "eventloop.h"
#include "callback.h"namespace tiny_muduo {class Channel
{public:Channel(EventLoop* loop, const int& fd);~Channel();void HandleEvent();void SetReadCallback(const ReadCallback& callback) { read_callback_ = callback; }void SetWriteCallback(const WriteCallback& callback) {write_callback_ = callback;}void EnableReading() {events_ |= EPOLLIN; Update();  }void EnableWriting() {events_ |= EPOLLOUT;Update();}void Update() {loop_->Update(this);}void SetReceivedEvents(int events) {recv_events_ = events;}int fd()  { return fd_; } int events()  { return events_; }int recv_events() { return recv_events_; }private:EventLoop* loop_;int fd_;int events_;         // update eventsint recv_events_;    // epoll received eventsReadCallback read_callback_;WriteCallback write_callback_;
};}
#endif

4、channel.cc

#include "channel.h"#include <sys/epoll.h>using namespace tiny_muduo;Channel::Channel(EventLoop* loop,const int& fd): loop_(loop),fd_(fd),events_(0),recv_events_(0) {}void Channel::HandleEvent() {if (recv_events_ & EPOLLIN) {read_callback_();} else if (recv_events_ & EPOLLOUT) {write_callback_();} else {}
}

5、tcpconnectionptr.h

#ifndef TINY_MUDUO_TCPCONNECTIONPTR_H_
#define TINY_MUDUO_TCPCONNECTIONPTR_H_#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>#include <string> #include "callback.h"
#include "channel.h"using std::string;namespace tiny_muduo {class EventLoop;class TcpConnectionPtr {public:TcpConnectionPtr(EventLoop* loop,int connfd);~TcpConnectionPtr();void SetConnectionCallback(const ConnectionCallback& callback) { connection_callback_ = callback;}void SetMessageCallback(const MessageCallback& callback) {message_callback_ = callback;}void ConnectionEstablished() {channel_->EnableReading();connection_callback_(this);}void HandleMessage();void Send(const string& str);string Get();private:int Recv() {memset(buf_, '\0', sizeof(buf_));int ret = recv(connfd_, buf_, 100, 0);return ret;}EventLoop* loop_;int connfd_;Channel* channel_;char buf_[100] = {0};ConnectionCallback connection_callback_;MessageCallback message_callback_;
};}  // namespace tiny_muduo
#endif

5、tcpconnectionptr.cc

#include "tcpconnectionptr.h"#include <sys/types.h>
#include <sys/socket.h>#include "channel.h"using namespace tiny_muduo;TcpConnectionPtr::TcpConnectionPtr(EventLoop* loop, int connfd) : loop_(loop),connfd_(connfd),channel_(new Channel(loop_, connfd_)) {channel_->SetReadCallback(std::bind(&TcpConnectionPtr::HandleMessage, this));
}void TcpConnectionPtr::HandleMessage() {if (Recv() > 0) {message_callback_(this);}
}void TcpConnectionPtr::Send(const string& message) {strcpy(buf_,message.c_str());send(connfd_, (const void *)(buf_), sizeof(buf_), 0);
}std::string TcpConnectionPtr::Get() {string message(buf_);memset(buf_, '\0', sizeof(buf_));return message;
}

6、eventloop.h

#ifndef TINY_MUDUO_EVENTLOOP_H_
#define TINY_MUDUO_EVENTLOOP_H_#include <stdint.h>
#include <unistd.h>
#include <sys/eventfd.h>
#include <pthread.h>#include <vector>
#include <functional>#include "mutex.h"
#include "epoller.h"namespace tiny_muduo {class Epoller;
class Channel;class EventLoop {public:typedef std::vector<Channel*> Channels;typedef std::function<void()> BasicFunc; typedef std::vector<BasicFunc> ToDoList;  EventLoop();~EventLoop();bool IsInThreadLoop() { return ::pthread_self() == tid_; }void Update(Channel* channel) { epoller_->Update(channel); }void Loop();void HandleRead();void RunOneFunc(const BasicFunc& func);void DoToDoList();pthread_t DebugShowTid() { return tid_; }private:pthread_t tid_; Epoller* epoller_;int wakeup_fd_;Channel* wakeup_channel_;Channels active_channels_;ToDoList to_do_list_;MutexLock mutex_;
};}  // namespace tiny_muduo
#endif

6、eventloop.cc

#include "eventloop.h"#include <unistd.h>
#include <sys/eventfd.h>
#include <pthread.h>#include "mutex.h"
#include "channel.h"using namespace tiny_muduo;EventLoop::EventLoop(): tid_(::pthread_self()),epoller_(new Epoller()),wakeup_fd_(::eventfd(0, EFD_NONBLOCK)),wakeup_channel_(new Channel(this, wakeup_fd_)) {wakeup_channel_->SetReadCallback(std::bind(&EventLoop::HandleRead, this));wakeup_channel_->EnableReading();
}EventLoop::~EventLoop() {}void EventLoop::Loop() {while (1) {epoller_->Poll(active_channels_);for (const auto& channel : active_channels_) {channel->HandleEvent();}active_channels_.clear();DoToDoList();}
}void EventLoop::HandleRead() {uint64_t read_one_byte = 1;::read(wakeup_fd_, &read_one_byte, sizeof(read_one_byte));return;
}void EventLoop::RunOneFunc(const BasicFunc& func) { if (IsInThreadLoop()) {   func(); } else {{  MutexLockGuard lock(mutex_);to_do_list_.emplace_back(func);}   if (!IsInThreadLoop()) {uint64_t write_one_byte = 1;  ::write(wakeup_fd_, &write_one_byte, sizeof(write_one_byte));}   }
}void EventLoop::DoToDoList() {ToDoList functors;{MutexLockGuard lock(mutex_);functors.swap(to_do_list_);}for (const auto& func : functors) {func();}
}

7、epoller.h

#ifndef TINY_MUDUO_EPOLLER_H_
#define TINY_MUDUO_EPOLLER_H_#include <sys/epoll.h>
#include <vector>namespace {const int kMaxEvents = 8;
}namespace tiny_muduo {class Channel;class Epoller {public: typedef std::vector<epoll_event> Events;typedef std::vector<Channel*> Channels;Epoller();void Poll(Channels& channels);int EpollWait()  { return epoll_wait(epollfd_, &*events_.begin(), kMaxEvents, -1); }  int SetNonBlocking(int fd);void FillActiveChannels(int eventnums, Channels& channels); void Update(Channel* channel);void UpdateChannel(int operation, Channel* channel);private: int epollfd_;Events events_;
};}
#endif

7、epoller.cc

#include "epoller.h"#include <string.h>
#include <sys/epoll.h>
#include <fcntl.h>#include "channel.h"using namespace tiny_muduo;Epoller::Epoller(): epollfd_(epoll_create(kMaxEvents)),events_(kMaxEvents) {}void Epoller::Poll(Channels& channels) {int eventnums = EpollWait();FillActiveChannels(eventnums, channels);
}void Epoller::FillActiveChannels(int eventnums, Channels& channels) {for (int i = 0; i < eventnums; ++i) {Channel* ptr = static_cast<Channel*> (events_[i].data.ptr);ptr->SetReceivedEvents(events_[i].events);channels.emplace_back(ptr);}
}int Epoller::SetNonBlocking(int fd) {int old_state = fcntl(fd, F_GETFL);int new_state = old_state | O_NONBLOCK;fcntl(fd, F_SETFL, new_state);return new_state;
}void Epoller::Update(Channel* channel) {int op = 0, events = channel->events();if (events & EPOLLIN) {op = EPOLL_CTL_ADD;SetNonBlocking(channel->fd());} else if (events & EPOLLRDHUP) {op = EPOLL_CTL_DEL;} else {}UpdateChannel(op, channel);
}void Epoller::UpdateChannel(int operation, Channel* channel)
{struct epoll_event event;memset(&event, '\0', sizeof(struct epoll_event));event.events = channel->events() | EPOLLET;event.data.ptr = static_cast<void*>(channel);epoll_ctl(epollfd_, operation, channel->fd(), &event);return;
}

8、eventloopthreadpool.h（新增文件）

#ifndef TINY_MUDUO_EVENTLOOPTHREADPOOL_H_
#define TINY_MUDUO_EVENTLOOPTHREADPOOL_H_#include <vector>namespace tiny_muduo {class EventLoopThread;
class EventLoop;class EventLoopThreadPool {public:typedef std::vector<EventLoopThread*> Thread;typedef std::vector<EventLoop*> Loop;EventLoopThreadPool(EventLoop* loop);~EventLoopThreadPool();void SetThreadNums(int thread_nums) {thread_nums_ = thread_nums;}void StartLoop();EventLoop* NextLoop();private:EventLoop* base_loop_;   Thread threads_;Loop loops_;int thread_nums_;int next_;
};}
#endif

8、eventloopthreadpool.cc（新增文件）

#include "eventloopthreadpool.h"#include "eventloopthread.h"using namespace tiny_muduo;EventLoopThreadPool::EventLoopThreadPool(EventLoop* loop): base_loop_(loop),threads_(),loops_(),thread_nums_(0),next_(0) {}EventLoopThreadPool::~EventLoopThreadPool() {}void EventLoopThreadPool::StartLoop() {for (int i = 0; i < thread_nums_; ++i) {EventLoopThread* ptr = new EventLoopThread();threads_.emplace_back(ptr);loops_.emplace_back(ptr->StartLoop());}
}EventLoop* EventLoopThreadPool::NextLoop() {EventLoop* ret = base_loop_;if (!loops_.empty()) {ret = loops_[next_];next_ = (next_ + 1) % thread_nums_;}return ret;
}

9、eventloopthread.h（新增文件）

#ifndef TINY_MUDUO_EVENTLOOPTHREAD_H
#define TINY_MUDUO_EVENTLOOPTHREAD_H#include "thread.h"
#include "mutex.h"
#include "condition.h"namespace tiny_muduo {class EventLoop;class EventLoopThread {public:EventLoopThread();~EventLoopThread();void StartFunc();EventLoop* StartLoop();private:EventLoop* loop_;Thread thread_;MutexLock mutex_;Condition cond_;
};}
#endif

9、eventloopthread.cc（新增文件）

#include "eventloopthread.h"#include <pthread.h>
#include <functional>#include "mutex.h"
#include "condition.h"
#include "eventloop.h"using namespace tiny_muduo;EventLoopThread::EventLoopThread(): loop_(nullptr),thread_(std::bind(&EventLoopThread::StartFunc, this)),mutex_(),cond_(mutex_) {}EventLoopThread::~EventLoopThread() {}        EventLoop* EventLoopThread::StartLoop() {thread_.StartThread();EventLoop* loop = nullptr;{   MutexLockGuard lock(mutex_);while (loop_ == nullptr) {cond_.Wait();}loop = loop_;}return loop;
}void EventLoopThread::StartFunc() {EventLoop loop;{MutexLockGuard lock(mutex_);loop_ = &loop;cond_.Signal();}loop_->Loop();{MutexLockGuard lock(mutex_);loop_ = nullptr;}
}

10、thread.h（新增文件）

#ifndef TINY_MUDUO_THREAD_H_
#define TINY_MUDUO_THREAD_H_#include <pthread.h>#include <functional>#include "latch.h"namespace tiny_muduo {class Thread {public:typedef std::function<void ()> ThreadFunc;Thread(const ThreadFunc& func);~Thread(); void StartThread();private:pthread_t pthread_id_;ThreadFunc func_;Latch latch_;
};       struct ThreadData {typedef tiny_muduo::Thread::ThreadFunc ThreadFunc;ThreadFunc func_;
Latch* latch_;ThreadData(ThreadFunc& func, Latch* latch): func_(func),latch_(latch) {}void RunOneFunc() {latch_->CountDown();latch_ = nullptr;  func_();
}
};}
#endif

10、thread.cc（新增文件）

#include "thread.h"#include <pthread.h>#include "latch.h"using namespace tiny_muduo;static void* ThreadRun(void* arg) {ThreadData* ptr = static_cast<ThreadData*>(arg);ptr->RunOneFunc();delete ptr;return nullptr;
}Thread::Thread(const ThreadFunc& func): pthread_id_(-1),func_(func),latch_(1) {}Thread::~Thread() {::pthread_detach(pthread_id_);
}void Thread::StartThread() {ThreadData* ptr = new ThreadData(func_, &latch_);::pthread_create(&pthread_id_, nullptr, ThreadRun, ptr);latch_.Wait();
}

3、其他组件（Address、Callback、Mutex、Condition、makefile等等）

1、address.h

#ifndef TINY_MUDUO_ADDRESS_H_
#define TINY_MUDUO_ADDRESS_H_#include <string>
#include <cstring>namespace tiny_muduo {class Address {private:const char* ip_;const int port_;public:Address(const char* port = "2022") : ip_("127.0.0.1"), port_(atoi(port)) {}const char* ip() const { return ip_; }const int port() const { return port_; }
};}
#endif

2、callback.h

#ifndef TINY_MUDUO_CALLBACK_H_
#define TINY_MUDUO_CALLBACK_H_#include <functional>using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;namespace tiny_muduo {class TcpConnectionPtr;typedef std::function<void (TcpConnectionPtr*)> ConnectionCallback;typedef std::function<void (TcpConnectionPtr*)> MessageCallback;typedef std::function<void ()> ReadCallback;typedef std::function<void ()> WriteCallback;
}
#endif

3、mutex.h（新增文件）

#ifndef TINY_MUDUO_MUTEX_H_
#define TINY_MUDUO_MUTEX_H_#include "pthread.h"namespace tiny_muduo {class MutexLock {public:MutexLock() {pthread_mutex_init(&mutex_, nullptr);}~MutexLock() {pthread_mutex_destroy(&mutex_);}bool Lock() {return pthread_mutex_lock(&mutex_) == 0;}bool Unlock() {return pthread_mutex_unlock(&mutex_) == 0; }pthread_mutex_t* mutex() { return &mutex_; } private:pthread_mutex_t mutex_;
};class MutexLockGuard {public:MutexLockGuard(MutexLock& mutex) : mutex_(mutex) {mutex_.Lock();}~MutexLockGuard() {mutex_.Unlock();}private:MutexLock& mutex_;
};}
#endif

4、condition.h（新增文件）

#ifndef TINY_MUDUO_CONDITION_H_
#define TINY_MUDUO_CONDITION_H_#include "pthread.h"#include "mutex.h"namespace tiny_muduo {class Condition {public:Condition(MutexLock& mutex) : mutex_(mutex) {pthread_cond_init(&cond_, nullptr);}~Condition() {pthread_cond_destroy(&cond_);}bool Wait() {int ret = 0;ret = pthread_cond_wait(&cond_, mutex_.mutex());return ret == 0;}bool Signal() {return pthread_cond_signal(&cond_);}bool BroadCast() {return pthread_cond_broadcast(&cond_);}private:MutexLock& mutex_;pthread_cond_t cond_;
}; }
#endif

5、latch.h（新增文件）

#ifndef TINY_MUDUO_LATCH_H_
#define TINY_MUDUO_LATCH_H_#include "mutex.h"
#include "condition.h"namespace tiny_muduo {class Latch {public:Latch(int count) : count_(count), mutex_(), cond_(mutex_) {}void CountDown() {MutexLockGuard lock(mutex_);--count_;if (count_ == 0) {cond_.BroadCast();}  }void Wait() {MutexLockGuard lock(mutex_);while (count_ > 0) {cond_.Wait();}}private:int count_;MutexLock mutex_;Condition cond_;
};}
#endif

6、makefile（注意链接 -lpthread）

CC = g++
CFLAG = -Wall -c
OBJS = main.o echo.o tcpserver.o acceptor.o\channel.o eventloop.o epoller.o tcpconnectionptr.o\eventloopthreadpool.o eventloopthread.o thread.o $(TFLAG)
TFLAG = -lpthreadweb_server : $(OBJS) $(CC) $^ -o $@main.o : main.cc eventloop.h address.h echo.h$(CC) $(CFLAG) $< -o $@echo.o : echo.cc echo.h tcpserver.h$(CC) $(CFLAG) $< -o $@tcpserver.o : tcpserver.cc tcpserver.h acceptor.h tcpconnectionptr.h\eventloopthreadpool.h$(CC) $(CFLAG) $< -o $@acceptor.o : acceptor.cc acceptor.h address.h channel.h$(CC) $(CFLAG) $< -o $@channel.o : channel.cc channel.h$(CC) $(CFLAG) $< -o $@eventloop.o : eventloop.cc eventloop.h channel.h mutex.h$(CC) $(CFLAG) $< -o $@eventloopthreadpool.o : eventloopthreadpool.cc eventloopthreadpool.h eventloopthread.h$(CC) $(CFLAG) $< -o $@eventloopthread.o : eventloopthread.cc eventloopthreadpool.h mutex.h\condition.h eventloop.h$(CC) $(CFLAG) $< -o $@thread.o : thread.cc thread.h latch.h$(CC) $(CFLAG) $< -o $@epoller.o : epoller.cc epoller.h channel.h$(CC) $(CFLAG) $< -o $@tcpconnectionptr.o : tcpconnectionptr.cc tcpconnectionptr.h \channel.h$(CC) $(CFLAG) $< -o $@.PHONY : clean
clean:rm *.o

4、tiny_muduo echo(One Loop Per Thread + Thread Pool 默认8线程) test

下面大致放一张图吧我自己大致测试了一下确实是8个线程轮流接受任务回调那些也是基本上正常的那么简单的测试就到这里了

结束语

老规矩放一张自己平时的工作界面就是轮流看着这些个小窗口然后点来点去的没其他啥了

感冒了估计有点点严重但还好各位还是多注意一下身体吧身体是最重要的这段时间早晚温差大注意保暖

这篇就先写到这里吧写完回去点个外卖吃点药就在床上躺着了估计之后还会写个好几篇吧毕竟说实话还有太多太多地方需要改了还有一些小组件涉及效率的也要改我看着我的tcpconnection读写我都看不下去还有后面还要认真看一下内存泄漏如何用shared_ptr unique_ptr weak_ptr来管理内存和完成线程安全的工作呢这里还是相当重要的

总之还有很长的路要走当然走到现在回想起前段时间连入手都不知道怎么入到现在基本框架都被我嗯整整出来了哈哈想着还是开心的
可能是功夫不负有心人吧或者是上天还是一直非常眷顾我的毕竟平时也是善人一个尽管很喜欢口嗨有的时候还会骂人哈哈
但是从结果上来看到现在是好的那就够了

好了那这篇博客就先写到这里吧我也收拾收拾电脑收拾收拾书把药拿着回寝室休息了回去好好休息休息各位下篇再见了~