add muduo code notes

Author: herongwei

NetPrograming/MuduoPlus/muduo/net/Acceptor.cc

@@ -0,0 +1,91 @@
+// Copyright 2021. rongweihe All rights reserved.
+// https://github.com/rongweihe/CPPNotes/tree/master/NetPrograming
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the License file.
+//
+// This is a public header file, it must only include public header files.
+
+#include "muduo/net/Acceptor.h"
+
+#include "muduo/base/Logging.h"
+#include "muduo/net/EventLoop.h"
+#include "muduo/net/InetAddress.h"
+#include "muduo/net/SocketsOps.h"
+
+#include <errno.h>
+#include <fcntl.h>
+//#include <sys/types.h>
+//#include <sys/stat.h>
+#include <unistd.h>
+
+using namespace muduo;
+using namespace muduo::net;
+
+//Acceptor的 socket 是 listen socket channel 用于观察此 socket 的 readable 事件 并回调 handleRead 后者会调用 accept 接受连接
+//构造函数执行创建 TCP 服务端的传统步骤: Socket bind listen (acceptSocket_ 封装了其步骤) 创建了非阻塞的 socket
+Acceptor::Acceptor(EventLoop* loop, const InetAddress& listenAddr, bool reuseport)
+  : loop_(loop),
+    acceptSocket_(sockets::createNonblockingOrDie(listenAddr.family())),
+    acceptChannel_(loop, acceptSocket_.fd()),
+    listening_(false),
+    idleFd_(::open("/dev/null", O_RDONLY | O_CLOEXEC))
+{
+  assert(idleFd_ >= 0);
+  acceptSocket_.setReuseAddr(true);
+  acceptSocket_.setReusePort(reuseport);
+  acceptSocket_.bindAddress(listenAddr);
+  acceptChannel_.setReadCallback(
+      std::bind(&Acceptor::handleRead, this));
+}
+
+Acceptor::~Acceptor()
+{
+  acceptChannel_.disableAll();
+  acceptChannel_.remove();
+  ::close(idleFd_);
+}
+
+void Acceptor::listen()
+{
+  loop_->assertInLoopThread();
+  listening_ = true;
+  acceptSocket_.listen();
+  acceptChannel_.enableReading();
+}
+
+//socket 可读的时候调用 Acceptor::handleRead 后者会接受 accept 并回调 newConnectionCallback_
+void Acceptor::handleRead()
+{
+    loop_->assertInLoopThread();
+    InetAddress peerAddr;
+    //FIXME loop until no more
+    int connfd = acceptSocket_.accept(&peerAddr);
+    if (connfd >= 0)
+    {
+        // string hostport = peerAddr.toIpPort();
+        // LOG_TRACE << "Accepts of " << hostport;
+        if (newConnectionCallback_)
+        {
+            newConnectionCallback_(connfd, peerAddr);
+        }
+        else
+        {
+            sockets::close(connfd);
+        }
+    }
+    else
+    {
+        LOG_SYSERR << "in Acceptor::handleRead";
+        // Read the section named "The special problem of
+        // accept()ing when you can't" in libev's doc.
+        // By Marc Lehmann, author of libev.
+        if (errno == EMFILE)
+        {
+            ::close(idleFd_);
+            idleFd_ = ::accept(acceptSocket_.fd(), NULL, NULL);
+            ::close(idleFd_);
+            idleFd_ = ::open("/dev/null", O_RDONLY | O_CLOEXEC);
+        }
+    }
+}

NetPrograming/MuduoPlus/muduo/net/Acceptor.h

@@ -0,0 +1,60 @@
+// Copyright 2021. rongweihe All rights reserved.
+// https://github.com/rongweihe/CPPNotes/tree/master/NetPrograming
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the License file.
+//
+// This is a public header file, it must only include public header files.
+
+
+#ifndef MUDUO_NET_ACCEPTOR_H
+#define MUDUO_NET_ACCEPTOR_H
+
+#include <functional>
+
+#include "muduo/net/Channel.h"
+#include "muduo/net/Socket.h"
+
+namespace muduo
+{
+namespace net
+{
+
+class EventLoop;
+class InetAddress;
+///
+/// Acceptor of incoming TCP connections.
+/// acceptor 负责 accept 新连接，并将新连接分发到 subReactor。
+class Acceptor : noncopyable
+{
+
+public:
+    typedef std::function<void (int sockfd, const InetAddress&)> NewConnectionCallback;
+    Acceptor(EventLoop* loop, const InetAddress& listenAddr, bool reuseport);
+    ~Acceptor();
+
+    void setNewConnectionCallback(const NewConnectionCallback& cb)
+    { newConnectionCallback_ = cb; }
+
+    void listen();
+
+    bool listening() const { return listening_; }
+
+    // Deprecated, use the correct spelling one above.
+    // Leave the wrong spelling here in case one needs to grep it for error messages.
+    // bool listenning() const { return listening(); }
+
+private:
+    void handleRead(); 
+    EventLoop* loop_;
+    Socket acceptSocket_;
+    Channel acceptChannel_;
+    NewConnectionCallback newConnectionCallback_;
+    bool listening_;
+    int idleFd_;
+};
+
+}   //namespace net
+}   //namespace muduo
+
+#endif  // MUDUO_NET_ACCEPTOR_H

NetPrograming/MuduoPlus/muduo/net/EventLoopThreadPool.cc

@@ -0,0 +1,80 @@
+// Copyright 2021 rongweihe.  All rights reserved.
+// https://github.com/rongweihe/CPPNotes/tree/master/NetPrograming
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the License file.
+
+
+#include "muduo/net/EventLoopThreadPool.h"
+
+#include "muduo/net/EventLoop.h"
+#include "muduo/net/EventLoopThread.h"
+
+#include <stdio.h>
+
+using namespace muduo;
+using namespace muduo::net;
+
+EventLoopThreadPool::EventLoopThreadPool(EventLoop* baseLoop, const string& nameArg)
+	: baseLoop_(baseLoop),
+	name_(nameArg),
+	started_(fasle),
+	numThreads_(0),
+	next_(0)
+{
+
+}
+
+EventLoopThreadPool::~EventLoopThreadPool()
+{
+  // Don't delete loop, it's stack variable
+}
+
+// round-robin 算法选择下一个 loop
+//轮询调度（Round Robin Scheduling）算法就是以轮询的方式依次将请求调度不同的服务器，
+//即每次调度执行i = (i + 1) mod n，并选出第i台服务器。 算法的优点是其简洁性，它无需记录当前所有连接的状态，所以它是一种无状态调度。
+EventLoop* EventLoopThreadPool::getNextLoop()
+{
+	baseLoop_->assertInLoopThread();
+	assert(started_);
+	EventLoop* loop = baseLoop_;
+
+	if (!loops_.empty()) 
+	{
+		//rounf-robin
+		loop = loops_[next_];
+		++next_;
+		if (implicit_cast<size_t>(next_) >= loops_.size())
+		{
+			next_ = 0;
+		}
+	}
+	return loop;
+}
+
+EventLoop* EventLoopThreadPool::getLoopForHash(size_t hashCode)
+{
+  baseLoop_->assertInLoopThread();
+  EventLoop* loop = baseLoop_;
+
+  if (!loops_.empty())
+  {
+    loop = loops_[hashCode % loops_.size()];
+  }
+  return loop;
+}
+
+//返回所有的loops
+std::vector<EventLoop*> EventLoopThreadPool::getAllLoops()
+{
+  baseLoop_->assertInLoopThread();
+  assert(started_);
+  if (loops_.empty())
+  {
+    return std::vector<EventLoop*>(1, baseLoop_);
+  }
+  else
+  {
+    return loops_;
+  }
+}

NetPrograming/MuduoPlus/muduo/net/EventLoopThreadPool.h

@@ -0,0 +1,41 @@
+// Copyright 2021. rongweihe All rights reserved.
+// https://github.com/rongweihe/CPPNotes/tree/master/NetPrograming
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the License file.
+//
+// This is a public header file, it must only include public header files.
+
+#ifndef MUDUO_NET_EVENTLOOPTHREAD_H
+#define MUDUO_NET_EVENTLOOPTHREAD_H
+
+#include "muduo/base/Condition.h"
+#include "muduo/base/Mutex.h"
+#include "muduo/base/Thread.h"
+
+namespace muduo
+{
+namespace net
+{
+
+class EventLoop;
+class EventLoopThread : noncopyable
+{
+public:
+	typedef std::function<void(EventLoop*)> ThreadInitCallback;
+	EventLoopThread(const ThreadInitCallback& cb = ThreadInitCallback(),
+                	const string& name = string());
+	~EventLoopThread();
+	EventLoop* startLoop();
+private:
+	void threadFunc();
+	EventLoop* loop_ GUARDED_BY(mutex_);
+	bool exiting_;
+	Thread thread_;
+	MutexLock mutex_;
+	Condition cond_ GUARDED_BY(mutex_);
+	ThreadInitCallback callback_;
+};
+    
+}	//namespace net
+}	//namespace muduo