四个 服务器设计模型(42)

最新推荐文章于 2024-06-29 22:31:19 发布
最新推荐文章于 2024-06-29 22:31:19 发布
阅读量5.5k 收藏 4
点赞数
分类专栏： Muduo Library Simple
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohan_/article/details/14323239
版权

五个简单TCP协议（MuduoManual.pdf P50）
muduo库网络模型使用示例（sudoku求解服务器MuduoManual.pdf P35 ）

reactor（一个IO线程）

reactor + threadpool (一个IO + 多个计算线程)

multiple reactor （多个IO线程）

one loop per thread + thread pool （多个IO线程 + 计算线程池）


网络编程关注4个半事件：
连接建立
连接断开
消息到达
信息发送完毕（对于低流量的服务来说，通常不需要关注该事件）

如何实现server
1 提供一个xxxServer类
2 在该类中包含一个TcpServer对象
注册一些事件
OnConnection
OnMessage
OnWriteComplete

TcpConnection::shutdown （） 内部实现，只关闭写入这一半

--------------------------------------

----------------------------------------

下面的程序都是用来解 数独 的，数独的实现如下

sudoku.h

#ifndef MUDUO_EXAMPLES_SUDOKU_SUDOKU_H
#define MUDUO_EXAMPLES_SUDOKU_SUDOKU_H


#include <muduo/base/Types.h>

// FIXME, use (const char*, len) for saving memory copying.
muduo::string solveSudoku(const muduo::string& puzzle);
const int kCells = 81;

#endif


sudoku.cc


#include "sudoku.h"

#include <vector>
#include <assert.h>
#include <string.h>

using namespace muduo;

struct Node;
typedef Node Column;
struct Node
{
    Node* left;
    Node* right;
    Node* up;
    Node* down;
    Column* col;
    int name;
    int size;
};

const int kMaxNodes = 1 + 81*4 + 9*9*9*4;
const int kMaxColumns = 400;
const int kRow = 100, kCol = 200, kBox = 300;

class SudokuSolver
{
 public:
    SudokuSolver(int board[kCells])
      : inout_(board),
        cur_node_(0)
    {
        stack_.reserve(100);

        root_ = new_column();
        root_->left = root_->right = root_;
        memset(columns_, 0, sizeof(columns_));

        bool rows[kCells][10] = { {false} };
        bool cols[kCells][10] = { {false} };
        bool boxes[kCells][10] = { {false} };

        for (int i = 0; i < kCells; ++i) {
            int row = i / 9;
            int col = i % 9;
            int box = row/3*3 + col/3;
            int val = inout_[i];
            rows[row][val] = true;
            cols[col][val] = true;
            boxes[box][val] = true;
        }

        for (int i = 0; i < kCells; ++i) {
            if (inout_[i] == 0) {
                append_column(i);
            }
        }

        for (int i = 0; i < 9; ++i) {
            for (int v = 1; v < 10; ++v) {
                if (!rows[i][v])
                    append_column(get_row_col(i, v));
                if (!cols[i][v])
                    append_column(get_col_col(i, v));
                if (!boxes[i][v])
                    append_column(get_box_col(i, v));
            }
        }

        for (int i = 0; i < kCells; ++i) {
            if (inout_[i] == 0) {
                int row = i / 9;
                int col = i % 9;
                int box = row/3*3 + col/3;
                //int val = inout[i];
                for (int v = 1; v < 10; ++v) {
                    if (!(rows[row][v] || cols[col][v] || boxes[box][v])) {
                        Node* n0 = new_row(i);
                        Node* nr = new_row(get_row_col(row, v));
                        Node* nc = new_row(get_col_col(col, v));
                        Node* nb = new_row(get_box_col(box, v));
                        put_left(n0, nr);
                        put_left(n0, nc);
                        put_left(n0, nb);
                    }
                }
            }
        }
    }

    bool solve()
    {
        if (root_->left == root_) {
            for (size_t i = 0; i < stack_.size(); ++i) {
                Node* n = stack_[i];
                int cell = -1;
                int val = -1;
                while (cell == -1 || val == -1) {
                    if (n->name < 100)
                        cell = n->name;
                    else
                        val = n->name % 10;
                    n = n->right;
                }

                //assert(cell != -1 && val != -1);
                inout_[cell] = val;
            }
            return true;
        }

        Column* const col = get_min_column();
        cover(col);
        for (Node* row = col->down; row != col; row = row->down) {
            stack_.push_back(row);
            for (Node* j = row->right; j != row; j = j->right) {
                cover(j->col);
            }
            if (solve()) {
                return true;
            }
            stack_.pop_back();
            for (Node* j = row->left; j != row; j = j->left) {
                uncover(j->col);
            }
        }
        uncover(col);
        return false;
    }

 private:

    Column* root_;
    int*    inout_;
    Column* columns_[400];
    std::vector<Node*> stack_;
    Node    nodes_[kMaxNodes];
    int     cur_node_;

    Column* new_column(int n = 0)
    {
        assert(cur_node_ < kMaxNodes);
        Column* c = &nodes_[cur_node_++];
        memset(c, 0, sizeof(Column));
        c->left = c;
        c->right = c;
        c->up = c;
        c->down = c;
        c->col = c;
        c->name = n;
        return c;
    }

    void append_column(int n)
    {
        assert(columns_[n] == NULL);

        Column* c = new_column(n);
        put_left(root_, c);
        columns_[n] = c;
    }

    Node* new_row(int col)
    {
        assert(columns_[col] != NULL);
        assert(cur_node_ < kMaxNodes);

        Node* r = &nodes_[cur_node_++];

        //Node* r = new Node;
        memset(r, 0, sizeof(Node));
        r->left = r;
        r->right = r;
        r->up = r;
        r->down = r;
        r->name = col;
        r->col = columns_[col];
        put_up(r->col, r);
        return r;
    }

    int get_row_col(int row, int val)
    {
        return kRow+row*10+val;
    }

    int get_col_col(int col, int val)
    {
        return kCol+col*10+val;
    }

    int get_box_col(int box, int val)
    {
        return kBox+box*10+val;
    }

    Column* get_min_column()
    {
        Column* c = root_->right;
        int min_size = c->size;
        if (min_size > 1) {
            for (Column* cc = c->right; cc != root_; cc = cc->right) {
                if (min_size > cc->size) {
                    c = cc;
                    min_size = cc->size;
                    if (min_size <= 1)
                        break;
                }
            }
        }
        return c;
    }

    void cover(Column* c)
    {
        c->right->left = c->left;
        c->left->right = c->right;
        for (Node* row = c->down; row != c; row = row->down) {
            for (Node* j = row->right; j != row; j = j->right) {
                j->down->up = j->up;
                j->up->down = j->down;
                j->col->size--;
            }
        }
    }

    void uncover(Column* c)
    {
        for (Node* row = c->up; row != c; row = row->up) {
            for (Node* j = row->left; j != row; j = j->left) {
                j->col->size++;
                j->down->up = j;
                j->up->down = j;
            }
        }
        c->right->left = c;
        c->left->right = c;
    }

    void put_left(Column* old, Column* nnew)
    {
        nnew->left = old->left;
        nnew->right = old;
        old->left->right = nnew;
        old->left = nnew;
    }

    void put_up(Column* old, Node* nnew)
    {
        nnew->up = old->up;
        nnew->down = old;
        old->up->down = nnew;
        old->up = nnew;
        old->size++;
        nnew->col = old;
    }
};

string solveSudoku(const string& puzzle)
{
  assert(puzzle.size() == implicit_cast<size_t>(kCells));

  string result = "NoSolution";

  int board[kCells] = { 0 };
  bool valid = true;
  for (int i = 0; i < kCells; ++i)
  {
    board[i] = puzzle[i] - '0';
    valid = valid && (0 <= board[i] && board[i] <= 9);
  }

  if (valid)
  {
    SudokuSolver s(board);
    if (s.solve())
    {
      result.clear();
      result.resize(kCells);
      for (int i = 0; i < kCells; ++i)
      {
        result[i] = static_cast<char>(board[i] + '0');
      }
    }
  }
  return result;
}



reactor模型

只有一个IO线程：
    这个IO线程既负责listenfd也负责connfd

#include "sudoku.h"

#include <muduo/base/Atomic.h>
#include <muduo/base/Logging.h>
#include <muduo/base/Thread.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/InetAddress.h>
#include <muduo/net/TcpServer.h>

#include <boost/bind.hpp>

#include <utility>

#include <mcheck.h>
#include <stdio.h>
#include <unistd.h>

using namespace muduo;
using namespace muduo::net;

class SudokuServer
{
 public:
  SudokuServer(EventLoop* loop, const InetAddress& listenAddr)
    : loop_(loop),
      server_(loop, listenAddr, "SudokuServer"),
      startTime_(Timestamp::now())
  {
    server_.setConnectionCallback(
        boost::bind(&SudokuServer::onConnection, this, _1));
    server_.setMessageCallback(
        boost::bind(&SudokuServer::onMessage, this, _1, _2, _3));
  }

  void start()
  {
    server_.start();
  }

 private:
  void onConnection(const TcpConnectionPtr& conn)
  {
    LOG_TRACE << conn->peerAddress().toIpPort() << " -> "
        << conn->localAddress().toIpPort() << " is "
        << (conn->connected() ? "UP" : "DOWN");
  }

  void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)
  {
    LOG_DEBUG << conn->name();
    size_t len = buf->readableBytes();
    while (len >= kCells + 2)
    {
      const char* crlf = buf->findCRLF();
      if (crlf)
      {
        string request(buf->peek(), crlf);
        buf->retrieveUntil(crlf + 2);
        len = buf->readableBytes();
        if (!processRequest(conn, request))
        {
          conn->send("Bad Request!\r\n");
          conn->shutdown();
          break;
        }
      }
      else if (len > 100) // id + ":" + kCells + "\r\n"
      {
        conn->send("Id too long!\r\n");
        conn->shutdown();
        break;
      }
      else
      {
        break;
      }
    }
  }

  bool processRequest(const TcpConnectionPtr& conn, const string& request)
  {
    string id;
    string puzzle;
    bool goodRequest = true;

    string::const_iterator colon = find(request.begin(), request.end(), ':');
    if (colon != request.end())
    {
      id.assign(request.begin(), colon);
      puzzle.assign(colon+1, request.end());
    }
    else
    {
      puzzle = request;
    }

    if (puzzle.size() == implicit_cast<size_t>(kCells))
    {
      LOG_DEBUG << conn->name();
      string result = solveSudoku(puzzle);
      if (id.empty())
      {
        conn->send(result+"\r\n");
      }
      else
      {
        conn->send(id+":"+result+"\r\n");
      }
    }
    else
    {
      goodRequest = false;
    }
    return goodRequest;
  }

  EventLoop* loop_;
  TcpServer server_;
  Timestamp startTime_;
};

int main(int argc, char* argv[])
{
  LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
  EventLoop loop;
  InetAddress listenAddr(9981);
  SudokuServer server(&loop, listenAddr);

  server.start();

  loop.loop();
}


multiple reactor
IO线程的数目多个
EventLoopThreadPoll IO线程池
直接设置server_.setThreadNum(numThreads)就OK了

main reactor 负责listenfd accept
sub reactor  负责connfd
使用roundbin轮叫策略
来一个连接，就选择下一个EventLoop，这样让多个连接分配给若干个EventLoop来处理，
而每个EventLoop属于一个IO线程，也就意味着，多个连接分配给若干个IO线程来处理。

include "sudoku.h"

#include <muduo/base/Atomic.h>
#include <muduo/base/Logging.h>
#include <muduo/base/Thread.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/InetAddress.h>
#include <muduo/net/TcpServer.h>

#include <boost/bind.hpp>

#include <utility>

#include <mcheck.h>
#include <stdio.h>
#include <unistd.h>

using namespace muduo;
using namespace muduo::net;

class SudokuServer
{
 public:
  SudokuServer(EventLoop* loop, const InetAddress& listenAddr, int numThreads)
    : loop_(loop),
      server_(loop, listenAddr, "SudokuServer"),
      numThreads_(numThreads),
      startTime_(Timestamp::now())
  {
    server_.setConnectionCallback(
        boost::bind(&SudokuServer::onConnection, this, _1));
    server_.setMessageCallback(
        boost::bind(&SudokuServer::onMessage, this, _1, _2, _3));
    server_.setThreadNum(numThreads);
  }

  void start()
  {
    LOG_INFO << "starting " << numThreads_ << " threads.";
    server_.start();
  }

 private:
  void onConnection(const TcpConnectionPtr& conn)
  {
    LOG_TRACE << conn->peerAddress().toIpPort() << " -> "
        << conn->localAddress().toIpPort() << " is "
        << (conn->connected() ? "UP" : "DOWN");
  }

  void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)
  {
    LOG_DEBUG << conn->name();
    size_t len = buf->readableBytes();
    while (len >= kCells + 2)
    {
      const char* crlf = buf->findCRLF();
      if (crlf)
      {
        string request(buf->peek(), crlf);
        buf->retrieveUntil(crlf + 2);
        len = buf->readableBytes();
        if (!processRequest(conn, request))
        {
          conn->send("Bad Request!\r\n");
          conn->shutdown();
          break;
        }
      }
      else if (len > 100) // id + ":" + kCells + "\r\n"
      {
        conn->send("Id too long!\r\n");
        conn->shutdown();
        break;
      }
      else
      {
        break;
      }
    }
  }

  bool processRequest(const TcpConnectionPtr& conn, const string& request)
  {
    string id;
    string puzzle;
    bool goodRequest = true;

    string::const_iterator colon = find(request.begin(), request.end(), ':');
    if (colon != request.end())
    {
      id.assign(request.begin(), colon);
      puzzle.assign(colon+1, request.end());
    }
    else
    {
      puzzle = request;
    }

    if (puzzle.size() == implicit_cast<size_t>(kCells))
    {
      LOG_DEBUG << conn->name();
      string result = solveSudoku(puzzle);
      if (id.empty())
      {
        conn->send(result+"\r\n");
      }
      else
      {
        conn->send(id+":"+result+"\r\n");
      }
    }
    else
    {
      goodRequest = false;
    }
    return goodRequest;
  }

  EventLoop* loop_;
  TcpServer server_;
  int numThreads_;
  Timestamp startTime_;
};

int main(int argc, char* argv[])
{
  LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
  int numThreads = 0;
  if (argc > 1)
  {
    numThreads = atoi(argv[1]);
  }
  EventLoop loop;
  InetAddress listenAddr(9981);
  SudokuServer server(&loop, listenAddr, numThreads);

  server.start();

  loop.loop();
}


reactor + threadPool

一个IO线程，多个计算thread的模式
EventLoop + threadpool + numThreads_

include "sudoku.h"

#include <muduo/base/Atomic.h>
#include <muduo/base/Logging.h>
#include <muduo/base/Thread.h>
#include <muduo/base/ThreadPool.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/InetAddress.h>
#include <muduo/net/TcpServer.h>

#include <boost/bind.hpp>

#include <utility>

#include <mcheck.h>
#include <stdio.h>
#include <unistd.h>

using namespace muduo;
using namespace muduo::net;

class SudokuServer
{
 public:
  SudokuServer(EventLoop* loop, const InetAddress& listenAddr, int numThreads)
    : loop_(loop),
      server_(loop, listenAddr, "SudokuServer"),
      numThreads_(numThreads),
      startTime_(Timestamp::now())
  {
    server_.setConnectionCallback(
        boost::bind(&SudokuServer::onConnection, this, _1));
    server_.setMessageCallback(
        boost::bind(&SudokuServer::onMessage, this, _1, _2, _3));
  }

  void start()
  {
    LOG_INFO << "starting " << numThreads_ << " threads.";
    threadPool_.start(numThreads_);//线程池的线程个数
    server_.start();
  }

 private:
  void onConnection(const TcpConnectionPtr& conn)
  {
    LOG_TRACE << conn->peerAddress().toIpPort() << " -> "
        << conn->localAddress().toIpPort() << " is "
        << (conn->connected() ? "UP" : "DOWN");
  }

  void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)
  {
    LOG_DEBUG << conn->name();
    size_t len = buf->readableBytes();
    while (len >= kCells + 2)
    {
      const char* crlf = buf->findCRLF();
      if (crlf)
      {
        string request(buf->peek(), crlf);
        buf->retrieveUntil(crlf + 2);
        len = buf->readableBytes();
        if (!processRequest(conn, request))
        {
          conn->send("Bad Request!\r\n");
          conn->shutdown();
          break;
        }
      }
      else if (len > 100) // id + ":" + kCells + "\r\n"
      {
        conn->send("Id too long!\r\n");
        conn->shutdown();
        break;
      }
      else
      {
        break;
      }
    }
  }

  bool processRequest(const TcpConnectionPtr& conn, const string& request)
  {
    string id;
    string puzzle;
    bool goodRequest = true;

    string::const_iterator colon = find(request.begin(), request.end(), ':');
    if (colon != request.end())
    {
      id.assign(request.begin(), colon);
      puzzle.assign(colon+1, request.end());
    }
    else
    {
      puzzle = request;
    }
    /*计算线程中的线程进行处理*/
    if (puzzle.size() == implicit_cast<size_t>(kCells))
    {
      threadPool_.run(boost::bind(&solve, conn, puzzle, id));
    }
    else
    {
      goodRequest = false;
    }
    return goodRequest;
  }

  static void solve(const TcpConnectionPtr& conn,
                    const string& puzzle,
                    const string& id)
  {
    LOG_DEBUG << conn->name();
    string result = solveSudoku(puzzle);
    /*这里处理完数据后，conn->send() 还是在IO线程中发送，而不是
在计算线程中处理
    */
    if (id.empty())
    {
      conn->send(result+"\r\n");
    }
    else
    {
      conn->send(id+":"+result+"\r\n");
    }
  }

  EventLoop* loop_;
  TcpServer server_;
  ThreadPool threadPool_; //计算线程池
  int numThreads_;
  Timestamp startTime_;
};

int main(int argc, char* argv[])
{
  LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
  int numThreads = 0;
  if (argc > 1)
  {
    numThreads = atoi(argv[1]);
  }
  EventLoop loop;
  InetAddress listenAddr(9981);
  SudokuServer server(&loop, listenAddr, numThreads);

  server.start();

  loop.loop();
}



4 、multiple reactors+threadpool

EventLoopThreadPoll + threadpool + IOnumThreads_ + ThreadPoolnumThreads_



include "sudoku.h"

#include <muduo/base/Atomic.h>
#include <muduo/base/Logging.h>
#include <muduo/base/Thread.h>
#include <muduo/base/ThreadPool.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/InetAddress.h>
#include <muduo/net/TcpServer.h>

#include <boost/bind.hpp>

#include <utility>

#include <mcheck.h>
#include <stdio.h>
#include <unistd.h>

using namespace muduo;
using namespace muduo::net;

class SudokuServer
{
 public:
  SudokuServer(EventLoop* loop, const InetAddress& listenAddr, int numThreads)
    : loop_(loop),
      server_(loop, listenAddr, "SudokuServer"),
      numThreads_(numThreads),
      startTime_(Timestamp::now())
  {
    server_.setConnectionCallback(
        boost::bind(&SudokuServer::onConnection, this, _1));
    server_.setMessageCallback(
        boost::bind(&SudokuServer::onMessage, this, _1, _2, _3));
     server_.setThreadNum(numThreads);//IO线程池的初始化
  }

  void start()
  {
    LOG_INFO << "starting " << numThreads_ << " threads.";
    threadPool_.start(numThreads_);
    server_.start();
  }

 private:
  void onConnection(const TcpConnectionPtr& conn)
  {
    LOG_TRACE << conn->peerAddress().toIpPort() << " -> "
        << conn->localAddress().toIpPort() << " is "
        << (conn->connected() ? "UP" : "DOWN");
  }

  void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)
  {
    LOG_DEBUG << conn->name();
    size_t len = buf->readableBytes();
    while (len >= kCells + 2)
    {
      const char* crlf = buf->findCRLF();
      if (crlf)
      {
        string request(buf->peek(), crlf);
        buf->retrieveUntil(crlf + 2);
        len = buf->readableBytes();
        if (!processRequest(conn, request))
        {
          conn->send("Bad Request!\r\n");
          conn->shutdown();
          break;
        }
      }
      else if (len > 100) // id + ":" + kCells + "\r\n"
      {
        conn->send("Id too long!\r\n");
        conn->shutdown();
        break;
      }
      else
      {
        break;
      }
    }
  }

  bool processRequest(const TcpConnectionPtr& conn, const string& request)
  {
    string id;
    string puzzle;
    bool goodRequest = true;

    string::const_iterator colon = find(request.begin(), request.end(), ':');
    if (colon != request.end())
    {
      id.assign(request.begin(), colon);
      puzzle.assign(colon+1, request.end());
    }
    else
    {
      puzzle = request;
    }
    /*计算线程中的线程进行处理*/
    if (puzzle.size() == implicit_cast<size_t>(kCells))
    {
      threadPool_.run(boost::bind(&solve, conn, puzzle, id));
    }
    else
    {
      goodRequest = false;
    }
    return goodRequest;
  }

  static void solve(const TcpConnectionPtr& conn,
                    const string& puzzle,
                    const string& id)
  {
    LOG_DEBUG << conn->name();
    string result = solveSudoku(puzzle);
    /*这里处理完数据后，conn->send() 还是在IO线程中发送，而不是
在计算线程中处理
    */
    if (id.empty())
    {
      conn->send(result+"\r\n");
    }
    else
    {
      conn->send(id+":"+result+"\r\n");
    }
  }

  EventLoop* loop_;
  TcpServer server_;
  ThreadPool threadPool_;
  int numThreads_;
  Timestamp startTime_;
};

int main(int argc, char* argv[])
{
  LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
  int numThreads = 0;
  if (argc > 1)
  {
    numThreads = atoi(argv[1]);
  }
  EventLoop loop;
  InetAddress listenAddr(9981);
  SudokuServer server(&loop, listenAddr, numThreads);

  server.start();

  loop.loop();
}


--------------------------------------------------


sudoKu 求解服务器，既是一个IO密集型，又是一个计算密集型的服务

IO线程池 + 计算线程池
计算时间如果比较久，就会使得IO线程阻塞，IO线程很快就用尽，就不处理大量的并发连接
一个IO线程+计算线程池


使用muduo 库来编程还是比较容易的，有兴趣的朋友可以试一下！



【DDD】学习笔记-服务设计模型
xqdd的专栏
02-08 782
服务实现模型和服务模型驱动设计的过程
在Linux服务器上部署BERT预训练模型——展示了如何在Linux服务器上使用Docker容器部署BERT预
AI天才研究院
08-07 1969
自然语言处理（NLP）技术一直以来都是非常热门的研究领域。深度学习（DL）也逐渐成为NLP的重要组成部分，并且BERT预训练模型已经成为事实上的标准模型。因此，了解BERT预训练模型及其部署至生产环境是一个必不可少的技能。本文将以BERT预训练模型的部署方式来介绍如何在Linux服务器上使用Docker容器部署BERT预训练模型。
服务设计原理：服务模式和反模式
leagle
03-14 1561
　　服务设计系列的法则已经发展到最佳通信实践和取样相关编码的程度。本文提供了设计和实现网络服务的基本原理，并且对面向服务的体系结构(SOA)的相关概念做了一个简要的回顾，以及有关于几种模式和反模式的详细讨论，当构建网络服务时，开发者可以利用它们。它可应用于能进行网络服务开发和配置的任何编程语言或平台。 　　关于SOA设计原理系列 　　面向服务的体系结构(SOA)简介
微服务设计笔记（3）——服务建模
读万卷书，行万里路
08-04 466
1 好服务的特征 1.1 松耦合 松耦合指的是，修改一个服务，而另一个相关的服务，不需要修改。微服务的重要特点就是：能够独立修改和部署单个服务，而不会影响、甚至修改系统中的其它服务。 一个服务应该尽可能少地了解与之协作的服务信息。因为过度了解，会导致紧耦合。 1.2 高内聚 高内聚指的是，把相关的行为聚集在一起。这样，需要改变行为时，只需要在一处修改，然后独立发布。 我们需要做的是，找出业务领域...
CBF Studio业务建模示例（3）-服务应用模型设计
o983950935的博客
06-08 609
文章目录服务应用需求分析客户编号生成接口定义服务应用设计服务应用ADML逻辑 服务应用需求分析   实际上这个步骤属于应用模型范畴，在数据模型设计完成后，需要开始进行业务模型设计了，然后才是应用模型设计。但是服务模型是可以先行设计的，为的是对业务数据的访问和维护做标准化任务支撑，这些服务应用设计是可以直接在业务模型中复用的，间接的支持业务模型设计做。   因此服务应用模型设计一开始不需要很复杂，仅针对既有的数据模型做CRUD操作即可。以个人客户基本信息的创建、查询和更新为例分析如何设计服务接口，以及基本的
服务器设计系列 网络模型,从C10K谈起, 聊聊服务器的设计模型(上)
weixin_28829629的博客
08-11 271
从C10K谈起, 聊聊服务器的设计模型(上)15 Mar 2019C10K问题是个缩写, 其实就是Client 10 000问题, 也就是单机1w并发连接的解法 那么, 接下来我们就从各种网络编程模型谈起, 最后来说说怎么解决单机1w+并发连接的问题.说到网络编程的模型, 无非是这两种: 一个进程/线程服务一个连接一个进程/线程服务多个连接我们现在从这两种类型开始, 分析现有的网络编程模型:迭代服...
V100 GPU服务器安装CUDNN教程
weixin_43178406的博客
11-22 5万+
本文主要介绍了V100 GPU服务器安装CUDNN教程，希望能对安装V100 GPU服务器的同学们有所帮助。 文章目录 1. 背景描述 2. 下载CUDNN文件 3. 安装CUDNN 4. 检验CUDNN安装效果
服务器模型（二）
10-27 238
1、单线程/阻塞/同步模型 适用范围：单一连接 缺点：多连接时相互影响，一个阻塞，别的也得不到响应 2、多进程/阻塞/同步模型 适用范围：连接数较少，且使用的资源较多，比如文件操作 缺点：系统进程数有上限，不适用大量并发连接，且进程间切换开销较大 3、多线程/阻塞/同步模型 适用范围：连接数较少，且使用系统资源不多，可多个线程共享 缺点：系统
LLaMA模型系统解读
热门推荐
herosunly的博客
05-22 11万+
本文介绍核心内容为LLaMA模型系统解读，希望对学习和使用大模型的同学们有所帮助。 文章目录 1. 前言 2. LLaMA的核心目标和成功诀窍 2.1 核心目标 2.2 成功诀窍一 2.3 成功诀窍二 2.4 成功诀窍三 3. 常见误区 3.1 误区一 3.2 误区二 3.3 误区三 3.4 误区四
服务器模型（-）
10-27 211
1.常用服务器模型 a.迭代服务器 只有一个进程/线程处理请求 设计方法： 一般为单进程,加上select多路复用,非阻塞socket b.迭代/并发混合型服务器 平时迭代处理，对消耗大的请求并发处理 设计方法： 平时是迭代型的服务器 处理请求时设置一个超时，当请求的处理时间超时时，创建一个进程/线程，把处理转给新的进程/线程处理，主进程/线程继续处理其他请求 c.并发服务器
如何理解muduo线程池的特点--one loop per thread
m0_47891203的博客
09-28 822
main loop只负责响应新的客户端连接，客户端与服务端的交流在thread loop中完成。
半同步/半反应堆模型以及简单实现（二）
supermario19的博客
07-14 466
该模型不同于前文提到的半同步/半反应堆模型半同步/半反应堆模型以及简单实现（一）1. one thread one loop。主线程和每个工作线程之间都维持自己的事件循环，它们各自监听和处理不同的事件。2. 主线程只管理监听socket，连接socket由工作线程来处理。当有新的连接到来时，主线程就接受并将新返回的socket派发给某个工作线程，此后该socket上的任何I/O操作都由被选中的工作线程来处理。3. 主线程接受连接socket后，向工作线程的任务队列中插入一个任务，并且发送管道消息。工作线程检
【muduo源码学习】多线程下的 one loop per thread
升级打怪记录
04-16 1132
多线程多Reactor模型的实现，主要涉及 Thread、EventLoopThread 和 EventLoopThreadPool 这三个类，下面依次进行介绍。
一、C++项目：仿muduo库实现高性能高并发服务器
weixin_54447296的博客
09-21 2607
简单理解就是使用 I/O多路复用 统⼀监听事件，收到事件后分发给处理进程或线程，是编写高性能网络服务器的必备技术之⼀。当然准确来说，因为我们要实现的服务器本身并不存在业务，咱们要实现的应该算是⼀个高性能服务器基础库，是⼀个基础组件。并且，通过组件内提供的不同应⽤层协议支持，也可以快速完成⼀个高性能应⽤服务器的搭建（当前。在这里，要明确的是咱们要实现的是⼀个高并发服务器组件，因此当前的项目中并不包含实际的业务。通过咱们实现的高并发服务器组件，可以简洁快速的完成⼀个高性能的服务器搭建。
libevent实现多线程，one loop per thread，多线程通信
$firecat利白的代码足迹$
09-12 5497
libevent实现多线程 LibEvent代码阅读---线程间通信、信号处理 libevent并不是线程安全的，但这不代表libevent不支持多线程模式。 前几天在微博上看到ruanyf发了条微博说到apache和nginx的并发模型，看到评论很多人都说不对 于是自己又查了下，总结一下我所学过的网络库或者网络服务器的并发模型 1、muduo：one l
epoll模型设计海量级连接服务器
06-24
首先，`epoll`模型通过`epoll_create`、`epoll_ctl`、`epoll_wait`和`close`四个主要函数来管理事件。`epoll_create`创建一个`epoll`实例，`epoll_ctl`用来添加、删除或修改监控的文件描述符，`epoll_wait`则阻塞...
服务器编程四
cssdl的专栏
10-22 389
1、dao 如何写一个DAO step1
c++项目：one thread oneloop式并发服务器实现（一）
最新发布
weixin_43446897的博客
06-29 1440
更新中......前言：本项目基于muduo库，通过模仿，实现实现出一个高并发服务器组件，通过该组件，可以简洁快速的搭建出一个高性能的服务器。为了便于展示，本项目将实现一个基于Reactor模式的高性能TCP服务器。目标定位：本项目实现的是主从Reactor模型服务器，主Reactor线程仅仅监听描述符，获取新连接保证获取连接的高效性，提高服务器的性能；当主Reactor获取到新连接后，会分发给子Reactor进行事件监控，子Reactor线程根据各自的描述符的读写事件进行数据读写以及处理业务。
在Linux平台下简述One Loop One Thread思想
weixin_39380632的博客
08-09 1008
业精于勤，荒于嬉，再怎么忙也要坚持学习和积累，千万不能让自己深陷在公司的业务代码中而不能自拔。 要想具备多组服务的架构和开发能力，熟练服务端开发的相关知识是最基本的前提，从事服务器开发的同学肯定都听过One Loop One Thread思想；但是要把这种思想应用到实际的开发中，怎么去构建自己的服务器，让自己的服务能同时服务几千个甚至上万个客户端（单组服务做到极致），我相信很多同学都不具备这种能力（包括我自己）。 首先我再写一个服务端程序时，需要做哪些准备工作，采用哪种IO复用技术、创建多大的线程池、怎么去
net10. IO线程池类——EventLoopThreadPool
TABE_的博客
03-29 322
EventLoopThreadPool类 EventLoopThreadPool是事件循环线程池，管理所有客户端连接，每个线程都有唯一一个事件循环。可以调用setThreadNum设置线程的数目。 EventLoopThreadPool类又叫IO线程池类，由1个主线程+N个子线程组成，“1+N”的模式一般用在服务端，主线程用于接收所有客户端的连接请求，各子线程用于处理多个客户端的IO事件。给线程池分配客户端的时候采取循环分配的方式，保证线程池的负载平衡。多个客户端的IO操作可以对应于1个IO线程，但是1个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值