![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/03\/20260303115054-69a6cb1e92dda.png\")
<\/p>\n<\/p>\n\u00a0 \u00a0 \u00a0 \u00a0 \u524d\u9762\u6211\u4eec\u57fa\u4e8eTCP\u5b9e\u73b0\u4e86\u7b80\u5355\u4e86\u4e92\u52a8\u670d\u52a1\u5668\u3002\u4f46\u662f\u90a3\u662f\u8fdc\u8fdc\u4e0d\u591f\u7684，\u672c\u671f\u6211\u4eec\u5c06\u5b9e\u73b0\u4e00\u4e2a\u57fa\u4e8eTCP\u7684\u8fdc\u7a0b\u547d\u4ee4\u884c\u7ec8\u7aef<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u76f8\u5173\u4ee3\u7801\u63d0\u4ea4\u81f3\u4f5c\u8005\u7684\u4e2a\u4ebagitee：\u697c\u7530\u8389\u5b50\/Linux\u5b66\u4e60\u559c\u6b22\u8bf7\u70b9\u4e2a\u8d5e\u8c22\u8c22<\/p>\n
\u76ee\u5f55<\/p>\n
\u65e5\u5fd7<\/p>\n
\u7ebf\u7a0b\u6c60\u76f8\u5173<\/p>\n
\u7f51\u7edc\u5ba2\u6237\u7aef<\/p>\n
\u547d\u4ee4<\/p>\n
\u670d\u52a1\u5668<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u670d\u52a1\u5668\u4ee3\u7801<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u670d\u52a1\u5668\u8fd0\u884c<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u5ba2\u6237\u7aef\u8fd0\u884c<\/p>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u6d4b\u8bd5<\/p>\n
#pragma once<\/p>\n
#include <iostream>
\n#include <pthread.h>
\n#include <cstdio>
\n#include <string>
\n#include <memory>
\n#include <sstream>
\n#include <chrono>
\n#include <iomanip>
\n#include <ctime>
\n#include <unistd.h>
\n#include <filesystem> \/\/ C++17
\n#include <fstream>
\n\/\/RAII\u98ce\u683c\u4ee3\u7801：\u8d44\u6e90\u83b7\u53d6\u5373\u521d\u59cb\u5316
\n\/\/ \u4e92\u65a5\u9501\u7c7b，\u5c01\u88c5\u4e86pthread_mutex_t
\nclass Mutex
\n{
\n public:
\n Mutex()
\n {
\n pthread_mutex_init(&_lock, nullptr);
\n }
\n void Lock()
\n {
\n pthread_mutex_lock(&_lock);
\n }
\n pthread_mutex_t *Ptr()
\n {
\n return &_lock;
\n }
\n void Unlock()
\n {
\n pthread_mutex_unlock(&_lock);
\n }
\n ~Mutex()
\n {
\n pthread_mutex_destroy(&_lock);
\n }
\n private:
\n pthread_mutex_t _lock;
\n};<\/p>\n
class LockGuard \/\/ RAII\u98ce\u683c\u4ee3\u7801
\n{
\n public:
\n LockGuard(Mutex &lock):_lockref(lock)
\n {
\n _lockref.Lock();
\n }
\n ~LockGuard()
\n {
\n _lockref.Unlock();
\n }
\n private:
\n Mutex &_lockref;
\n};<\/p>\n
\/\/\u65e5\u5fd7\u672c\u4f53
\nnamespace Logger
\n{
\n enum class LogLevel
\n {
\n INFO, \/\/\/< \u4fe1\u606f\u6027\u6d88\u606f，\u8bb0\u5f55\u5e94\u7528\u7a0b\u5e8f\u7684\u6b63\u5e38\u8fd0\u884c\u72b6\u6001（\u5982\u542f\u52a8\u3001\u914d\u7f6e\u52a0\u8f7d\u7b49）
\n WARNING, \/\/\/< \u8b66\u544a，\u8868\u793a\u6f5c\u5728\u7684\u95ee\u9898\u6216\u975e\u9884\u671f\u7684\u60c5\u5f62，\u4f46\u5e94\u7528\u7a0b\u5e8f\u4ecd\u80fd\u7ee7\u7eed\u8fd0\u884c
\n ERROR, \/\/\/< \u9519\u8bef，\u8868\u793a\u53d1\u751f\u4e86\u4e25\u91cd\u7684\u64cd\u4f5c\u5931\u8d25，\u4f46\u4e0d\u5f71\u54cd\u6574\u4e2a\u5e94\u7528\u7a0b\u5e8f\u7684\u7ee7\u7eed\u8fd0\u884c
\n FATAL, \/\/\/< \u81f4\u547d\u9519\u8bef，\u8868\u793a\u4e25\u91cd\u7684\u6545\u969c，\u901a\u5e38\u4f1a\u5bfc\u81f4\u5e94\u7528\u7a0b\u5e8f\u7ec8\u6b62
\n DEBUG \/\/\/< \u8c03\u8bd5\u4fe1\u606f，\u7528\u4e8e\u5f00\u53d1\u548c\u6392\u9519\u9636\u6bb5，\u8bb0\u5f55\u8be6\u7ec6\u7684\u5185\u90e8\u72b6\u6001\u6216\u6d41\u7a0b
\n };
\n std::string LogLevelToString(LogLevel level)
\n {
\n switch (level)
\n {
\n case LogLevel::INFO:
\n return "INFO";
\n case LogLevel::WARNING:
\n return "WARNING";
\n case LogLevel::ERROR:
\n return "ERROR";
\n case LogLevel::FATAL:
\n return "FATAL";
\n case LogLevel::DEBUG:
\n return "DEBUG";
\n default:
\n return "UNKNOWN";
\n }
\n }
\n std::string GetCurrentDateTime()
\n {
\n auto now = std::chrono::system_clock::now();
\n std::time_t now_c = std::chrono::system_clock::to_time_t(now);<\/p>\n
std::tm tm_info; \/\/ \u7528\u6237\u63d0\u4f9b\u7684\u7f13\u51b2\u533a
\n localtime_r(&now_c, &tm_info); \/\/ POSIX \u7ebf\u7a0b\u5b89\u5168\u51fd\u6570<\/p>\n
std::ostringstream oss;
\n oss << std::put_time(&tm_info, "%Y-%m-%d %H:%M:%S");
\n return oss.str();
\n }
\n \/\/ \u8f93\u51fa\u89d2\u5ea6 — \u5237\u65b0\u7b56\u7565
\n \/\/ 1. \u663e\u793a\u5668\u6253\u5370
\n \/\/ 2. \u6587\u4ef6\u5199\u5165<\/p>\n
\/\/ \u65e5\u5fd7\u7684\u751f\u6210：
\n \/\/ 1. \u6784\u5efa\u65e5\u5fd7\u5b57\u7b26\u4e32
\n \/\/ 2. \u6839\u636e\u4e0d\u540c\u7684\u7b56\u7565，\u8fdb\u884c\u5237\u65b0<\/p>\n
\/\/\u7b56\u7565\u6a21\u5f0f\u63a5\u53e3
\n class LogStrategy
\n {
\n public:
\n virtual void LogRefresh(const std::string &message) = 0;
\n virtual ~LogStrategy() = default;
\n };
\n \/\/ \u63a7\u5236\u53f0\u65e5\u5fd7\u5237\u65b0\u7b56\u7565, \u65e5\u5fd7\u5c06\u6765\u8981\u5411\u663e\u793a\u5668\u6253\u5370
\n class ConsoleStrategy : public LogStrategy
\n {
\n public:
\n \/\/ \u663e\u793a\u5668\u6253\u5370\u7b56\u7565\u5237\u65b0
\n void LogRefresh(const std::string &message) override
\n {
\n LockGuard lockguard(_mutex);
\n std::cerr << message << std::endl; \/\/ ??
\n }
\n ~ConsoleStrategy()
\n {
\n }<\/p>\n
private:
\n Mutex _mutex;
\n };<\/p>\n
const std::string defaultpath = ".\/log";
\n const std::string defaultfilename = "log.txt";
\n namespace fs = std::filesystem;<\/p>\n
\/\/ \u6587\u4ef6\u7b56\u7565
\n class FileLogStrategy : public LogStrategy
\n {
\n public:
\n FileLogStrategy(const std::string &path = defaultpath, const std::string &name = defaultfilename)
\n : _logpath(path),
\n _logfilename(name)
\n {
\n if (std::filesystem::exists(_logpath))
\n return;<\/p>\n
try
\n {
\n std::filesystem::create_directories(_logpath);
\n }
\n catch(const std::filesystem::filesystem_error &e)
\n {
\n std::cerr << e.what() << '\\\\n';
\n }
\n if(!_logpath.empty()&&_logpath.back() != '\/')
\n _logpath += '\/';
\n }
\n \/\/ \u6587\u4ef6\u7b56\u7565\u5237\u65b0
\n void LogRefresh(const std::string &message) override
\n {
\n {
\n std::string targetlogfile = _logpath + _logfilename;
\n LockGuard lockguard(_mutex);
\n std::ofstream logFile(targetlogfile, std::ios::app);\/\/ \u4ee5\u8ffd\u52a0\u6a21\u5f0f\u6253\u5f00\u6587\u4ef6
\n if (!logFile.is_open())
\n {
\n std::cerr << "\u65e0\u6cd5\u6253\u5f00\u65e5\u5fd7\u6587\u4ef6: " << targetlogfile << std::endl;
\n return;
\n }
\n logFile << message << "\\\\n";
\n logFile.close();
\n }<\/p>\n
}<\/p>\n
~FileLogStrategy()
\n {
\n }<\/p>\n
private:
\n std::string _logpath;
\n std::string _logfilename;
\n Mutex _mutex;
\n };<\/p>\n
\/\/ \u6839\u636e\u65e5\u5fd7\u7b49\u7ea7\u5206\u7c7b\u4fdd\u5b58\u7684\u7b56\u7565\u7c7b
\n class LevelFileLogStrategy : public LogStrategy {
\n public:
\n \/**
\n * @brief \u6784\u9020\u51fd\u6570，\u6307\u5b9a\u65e5\u5fd7\u6839\u76ee\u5f55
\n * @param log_dir \u5b58\u653e\u7b49\u7ea7\u65e5\u5fd7\u6587\u4ef6\u7684\u76ee\u5f55，\u9ed8\u8ba4\u4e3a ".\/logs"
\n *\/
\n LevelFileLogStrategy(const std::string &log_dir = ".\/logs") : _log_dir(log_dir) {
\n \/\/ \u786e\u4fdd\u76ee\u5f55\u5b58\u5728
\n if (!std::filesystem::exists(_log_dir)) {
\n std::filesystem::create_directories(_log_dir);
\n }
\n \/\/ \u89c4\u8303\u5316\u76ee\u5f55\u8def\u5f84，\u672b\u5c3e\u6dfb\u52a0 '\/'
\n if (!_log_dir.empty() && _log_dir.back() != '\/') {
\n _log_dir += '\/';
\n }
\n }<\/p>\n
\/**
\n * @brief \u5237\u65b0\u65e5\u5fd7：\u6839\u636e\u7b49\u7ea7\u5199\u5165\u5bf9\u5e94\u6587\u4ef6
\n * @param message \u5b8c\u6574\u7684\u65e5\u5fd7\u6d88\u606f（\u683c\u5f0f\u7531 Logger::LogMessage \u751f\u6210）
\n *\/
\n void LogRefresh(const std::string &message) override {
\n \/\/ 1. \u4ece\u6d88\u606f\u4e2d\u63d0\u53d6\u65e5\u5fd7\u7b49\u7ea7
\n LogLevel level = extractLogLevel(message);
\n \/\/ 2. \u6784\u9020\u5bf9\u5e94\u7684\u6587\u4ef6\u540d（\u4f8b\u5982：INFO.log）
\n std::string filename = _log_dir + LogLevelToString(level) + ".log";<\/p>\n
\/\/ 3. \u7ebf\u7a0b\u5b89\u5168\u5730\u8ffd\u52a0\u5199\u5165\u6587\u4ef6
\n LockGuard lockguard(_mutex);
\n std::ofstream logFile(filename, std::ios::app);
\n if (!logFile.is_open()) {
\n std::cerr << "\u65e0\u6cd5\u6253\u5f00\u65e5\u5fd7\u6587\u4ef6: " << filename << std::endl;
\n return;
\n }
\n logFile << message << "\\\\n";
\n logFile.close();
\n }<\/p>\n
private:
\n std::string _log_dir; \/\/ \u65e5\u5fd7\u6839\u76ee\u5f55
\n Mutex _mutex; \/\/ \u6587\u4ef6\u5199\u5165\u4e92\u65a5\u9501<\/p>\n
\/**
\n * @brief \u4ece\u65e5\u5fd7\u6d88\u606f\u4e2d\u89e3\u6790\u51fa\u7b49\u7ea7
\n * @param msg \u5b8c\u6574\u65e5\u5fd7\u6d88\u606f，\u683c\u5f0f\u4e3a "[\u65f6\u95f4][\u7b49\u7ea7][PID][\u6587\u4ef6:\u884c\u53f7] \u7528\u6237\u5185\u5bb9"
\n * @return \u5bf9\u5e94\u7684 LogLevel \u679a\u4e3e\u503c，\u89e3\u6790\u5931\u8d25\u65f6\u9ed8\u8ba4\u8fd4\u56de INFO
\n *\/
\n LogLevel extractLogLevel(const std::string &msg) {
\n \/\/ \u5bfb\u627e\u7b2c\u4e00\u4e2a ']' \u7684\u4f4d\u7f6e
\n size_t first_close = msg.find(']');
\n if (first_close == std::string::npos) {
\n return LogLevel::INFO; \/\/ \u683c\u5f0f\u9519\u8bef，\u9ed8\u8ba4 INFO
\n }
\n \/\/ \u5bfb\u627e\u7b2c\u4e8c\u4e2a '[' \u7684\u4f4d\u7f6e
\n size_t second_open = msg.find('[', first_close);
\n if (second_open == std::string::npos) {
\n return LogLevel::INFO;
\n }
\n \/\/ \u5bfb\u627e\u7b2c\u4e8c\u4e2a ']' \u7684\u4f4d\u7f6e
\n size_t second_close = msg.find(']', second_open);
\n if (second_close == std::string::npos) {
\n return LogLevel::INFO;
\n }
\n \/\/ \u63d0\u53d6\u7b49\u7ea7\u5b57\u7b26\u4e32（\u5982 "INFO"）
\n std::string level_str = msg.substr(second_open + 1, second_close – second_open – 1);<\/p>\n
\/\/ \u6620\u5c04\u5230 LogLevel \u679a\u4e3e
\n if (level_str == "INFO") return LogLevel::INFO;
\n if (level_str == "WARNING") return LogLevel::WARNING;
\n if (level_str == "ERROR") return LogLevel::ERROR;
\n if (level_str == "FATAL") return LogLevel::FATAL;
\n if (level_str == "DEBUG") return LogLevel::DEBUG;
\n return LogLevel::INFO; \/\/ \u672a\u77e5\u7b49\u7ea7，\u9ed8\u8ba4 INFO
\n }
\n };
\n class Logger
\n {
\n public:
\n Logger()
\n {}
\n void UseConsoleStrategy()
\n {
\n _strategy = std::make_unique<ConsoleStrategy>();
\n }
\n void UseFileStrategy()
\n {
\n _strategy = std::make_unique<FileLogStrategy>();
\n }
\n void UseLevelFileStrategy(const std::string &log_dir = ".\/logs")
\n {
\n _strategy = std::make_unique<LevelFileLogStrategy>(log_dir);
\n }
\n void Debug(const std::string &message)
\n {
\n if (_strategy!= nullptr)
\n {
\n _strategy->LogRefresh("[DEBUG] " + GetCurrentDateTime() + " – " + message);
\n }
\n }
\n \/\/\u65e5\u5fd7\u5185\u5bb9
\n \/\/\u4e00\u6761\u5b8c\u6574\u7684\u65e5\u5fd7\u4fe1\u606f=> [\u65e5\u5fd7\u7ea7\u522b] + \u5f53\u524d\u65f6\u95f4 + \u8fdb\u7a0bID + \u6587\u4ef6\u540d + \u884c\u53f7 + \u65e5\u5fd7\u4fe1\u606f
\n \/\/\u6211\u4eec\u60f3\u4ee5RAII\u5f62\u5f0f\u5237\u65b0\u65e5\u5fd7\u4fe1\u606f
\n class LogMessage
\n {
\n public:
\n LogMessage(LogLevel level, const std::string &filename, size_t line, Logger &logger)
\n : _level(level), _filename(filename), _line(line),_logger(logger)
\n {
\n _cur_time = GetCurrentDateTime();
\n _pid=getpid();
\n \/\/ \u6784\u5efa\u65e5\u5fd7\u5de6\u534a\u90e8\u5206\u4fe1\u606f
\n std::stringstream oss;
\n oss <<"["<<_cur_time<<"]"
\n <<"["<<LogLevelToString(_level)<<"]"
\n <<"["<<_pid<<"]"
\n <<"[" << filename << ":"
\n << line << "]";
\n _LogInfo = oss.str();
\n }
\n template<typename T>
\n LogMessage& operator<<(const T&info)
\n {
\n std::stringstream oss;
\n oss<< info;
\n _LogInfo += oss.str();
\n return *this;
\n }
\n ~LogMessage()
\n {
\n if (_logger._strategy != nullptr)
\n {
\n _logger._strategy->LogRefresh(_LogInfo);
\n }
\n }
\n private:
\n std::string _cur_time;
\n LogLevel _level;
\n pid_t _pid;
\n std::string _filename;
\n size_t _line;
\n std::string _LogInfo;
\n Logger &_logger ;\/\/\u65b9\u4fbf\u8fdb\u884c\u540e\u7eed\u7b56\u7565\u65b9\u5f0f\u5237\u65b0
\n };
\n \/\/\u5bf9LogMessage\u8fdb\u884c()\u91cd\u8f7d
\n \/\/\u5fc5\u987b\u7528\u62f7\u8d1d，\u5426\u5219\u4f1a\u5bfc\u81f4<<\u91cd\u8f7d\u7684\u65f6\u5019\u5185\u5bb9\u6d88\u5931
\n LogMessage operator()(LogLevel level, const std::string filename, size_t line)
\n {
\n return LogMessage(level, filename, line, *this);
\n }
\n ~Logger()
\n {}
\n private:
\n std::unique_ptr<LogStrategy> _strategy;
\n };
\n \/\/\u65e5\u5fd7\u5bf9\u8c61\u5168\u5c40\u4f7f\u7528
\n Logger logger;
\n #define ENABLE_LOG_CONSOLE() logger.UseConsoleStrategy()
\n #define ENABLE_LOG_FILE() logger.UseFileStrategy()
\n #define Log(level) logger(level, __FILE__, __LINE__)
\n #define ENABLE_LOG_LEVEL_FILE(log_dir) logger.UseLevelFileStrategy(log_dir)
\n}<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 Mutex.hpp<\/p>\n
#pragma once<\/p>\n
#include <iostream>
\n#include <string>
\n#include <pthread.h>
\n#include "..\/Log.h"
\nnamespace LockModule
\n{
\n \/\/ \u5bf9\u9501\u8fdb\u884c\u5c01\u88c5，\u53ef\u4ee5\u72ec\u7acb\u4f7f\u7528
\n class Mutex
\n {
\n public:
\n \/\/ \u5220\u9664\u4e0d\u9700\u8981\u7684\u62f7\u8d1d\u548c\u8d4b\u503c
\n Mutex(const Mutex &) = delete;
\n const Mutex &operator=(const Mutex &) = delete;<\/p>\n
\/\/ \u6784\u9020\u51fd\u6570
\n Mutex()
\n {
\n int n = pthread_mutex_init(&_mutex, nullptr);
\n (void)n;
\n }<\/p>\n
\/\/ \u52a0\u9501
\n void Lock()
\n {
\n int n = pthread_mutex_lock(&_mutex);
\n (void)n;
\n }<\/p>\n
\/\/ \u89e3\u9501
\n void Unlock()
\n {
\n int n = pthread_mutex_unlock(&_mutex);
\n (void)n;
\n }<\/p>\n
\/\/ \u83b7\u53d6\u539f\u59cb\u6307\u9488
\n pthread_mutex_t *GetMutexOriginal()
\n {
\n return &_mutex;
\n }<\/p>\n
\/\/ \u6790\u6784\u51fd\u6570
\n ~Mutex()
\n {
\n int n = pthread_mutex_destroy(&_mutex);
\n (void)n;
\n }<\/p>\n
private:
\n pthread_mutex_t _mutex;
\n };<\/p>\n
\/\/ \u91c7\u7528RAII\u98ce\u683c，\u8fdb\u884c\u9501\u7ba1\u7406
\n class LockGuard
\n {
\n public:
\n \/\/ \u6784\u9020\u51fd\u6570，\u521b\u5efa\u65f6\u81ea\u52a8\u52a0\u9501
\n LockGuard(Mutex &mutex) : _mutex(mutex)
\n {
\n _mutex.Lock();
\n }<\/p>\n
\/\/ \u6790\u6784\u51fd\u6570，\u81ea\u52a8\u89e3\u9501
\n ~LockGuard()
\n {
\n _mutex.Unlock();
\n }<\/p>\n
private:
\n Mutex &_mutex; \/\/ \u5f15\u7528\u88ab\u7ba1\u7406\u7684\u4e92\u65a5\u9501
\n };
\n} <\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 Cond.hpp<\/p>\n
#pragma once<\/p>\n
#include <iostream>
\n#include <string>
\n#include <pthread.h>
\n#include "Mutex.hpp"<\/p>\n
namespace CondModule
\n{
\n class Cond
\n {
\n public:
\n Cond()
\n {
\n pthread_cond_init(&_cond, nullptr);
\n }
\n void Wait(LockModule::Mutex &mutex)
\n {
\n int n = pthread_cond_wait(&_cond, mutex.GetMutexOriginal());
\n (void)n;
\n }
\n void Signal()
\n {
\n int n = pthread_cond_signal(&_cond);
\n (void)n;
\n }
\n void Broadcast()
\n {
\n int n = pthread_cond_broadcast(&_cond);
\n (void)n;
\n }
\n ~Cond()
\n {
\n pthread_cond_destroy(&_cond);
\n }
\n private:
\n pthread_cond_t _cond;
\n };
\n}<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 Thread.cpp<\/p>\n
#pragma once<\/p>\n
#include <iostream>
\n#include <string>
\n#include <functional>
\n#include <pthread.h>
\n#include "..\/Log.h"<\/p>\n
namespace ThreadPool
\n{
\n using namespace Logger;
\n static int gnumber = 1;
\n using callback_t = std::function<void()>;<\/p>\n
enum class TSTATUS
\n {
\n THREAD_NEW,
\n THREAD_RUNNING,
\n THREAD_STOP
\n };<\/p>\n
std::string Status2String(TSTATUS s)
\n {
\n switch (s)
\n {
\n case TSTATUS::THREAD_NEW:
\n return "THREAD_NEW";
\n case TSTATUS::THREAD_RUNNING:
\n return "THREAD_RUNNING";
\n case TSTATUS::THREAD_STOP:
\n return "THREAD_STOP";
\n default:
\n return "UNKNOWN";
\n }
\n }<\/p>\n
std::string IsJoined(bool joinable)
\n {
\n return joinable ? "true" : "false";
\n }<\/p>\n
class Thread
\n {
\n private:
\n void ToRunning()
\n {
\n _status = TSTATUS::THREAD_RUNNING;
\n }
\n void ToStop()
\n {
\n _status = TSTATUS::THREAD_STOP;
\n }
\n static void *ThreadRoutine(void *args)
\n {
\n Thread *self = static_cast<Thread *>(args);
\n pthread_setname_np(self->_tid, self->_name.c_str());
\n self->_cb();
\n self->ToStop();
\n return nullptr;
\n }<\/p>\n
public:
\n Thread(callback_t cb)
\n : _tid(-1), _status(TSTATUS::THREAD_NEW), _joinable(true), _cb(cb), _result(nullptr)
\n {
\n _name = "New-Thread-" + std::to_string(gnumber++);
\n }
\n bool Start()
\n {
\n int n = pthread_create(&_tid, nullptr, ThreadRoutine, this);
\n if (n != 0)
\n return false;<\/p>\n
ToRunning();
\n return true;
\n }
\n void Join()
\n {
\n if (_joinable)
\n {
\n int n = pthread_join(_tid, &_result);
\n if (n != 0)
\n {
\n std::cerr << "join error: " << n << std::endl;
\n return;
\n }
\n (void)_result;
\n _status = TSTATUS::THREAD_STOP;
\n Log(LogLevel::DEBUG) << _name << " join success";
\n }
\n else
\n {
\n std::cerr << "error, thread join status: " << IsJoined(_joinable) << std::endl;
\n }
\n }
\n \/\/ \u6682\u505c
\n \/\/ void Stop() \/\/ restart()
\n \/\/ {
\n \/\/ \/\/ \u8ba9\u7ebf\u7a0b\u6682\u505c
\n \/\/ }
\n void Die()
\n {
\n if (_status == TSTATUS::THREAD_RUNNING)
\n {
\n pthread_cancel(_tid);
\n _status = TSTATUS::THREAD_STOP;
\n }
\n }
\n void Detach()
\n {
\n if (_status == TSTATUS::THREAD_RUNNING && _joinable)
\n {
\n pthread_detach(_tid);
\n _joinable = false;
\n }
\n else
\n {
\n std::cerr << "detach " << _name << " failed" << std::endl;
\n }
\n }
\n void PrintInfo()
\n {
\n std::cout << "thread name : " << _name << std::endl;
\n std::cout << "thread _tid : " << _tid << std::endl;
\n std::cout << "thread _status : " << Status2String(_status) << std::endl;
\n std::cout << "thread _joinable : " << IsJoined(_joinable) << std::endl;
\n }<\/p>\n
~Thread()
\n {
\n }<\/p>\n
private:
\n std::string _name;
\n pthread_t _tid;
\n TSTATUS _status;
\n bool _joinable;
\n \/\/ \u7ebf\u7a0b\u8981\u6709\u81ea\u5df1\u7684\u4efb\u52a1\u5904\u7406，\u5373\u56de\u8c03\u51fd\u6570
\n callback_t _cb;<\/p>\n
\/\/ \u7ebf\u7a0b\u9000\u51fa\u4fe1\u606f
\n void *_result;
\n };
\n} <\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 ThreadPool.hpp<\/p>\n
#pragma once
\n#include "..\/Log.h"
\n#include "Thread.hpp"
\n#include "Mutex.hpp"
\n#include "Cond.hpp"
\n#include <iostream>
\n#include <memory>
\n#include <vector>
\n#include <queue><\/p>\n
namespace ThreadPool
\n{
\n using namespace Logger;
\n const int default_thread_num = 5;<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u51fd\u6570
\n void test()
\n {
\n while(1)
\n {
\n Log(LogLevel::DEBUG) << "\u6211\u662f\u4e00\u4e2a\u65b0\u7ebf\u7a0b,\u6211\u518d\u8fd0\u884cing….";
\n sleep(1);
\n }
\n }<\/p>\n
template<typename T>
\n class threadpool
\n {
\n private:
\n void HandlerTask()
\n {
\n char name[128];
\n pthread_getname_np(pthread_self(), name, sizeof(name));
\n while (true)
\n {
\n T task;
\n {
\n LockModule::LockGuard lockguard(_mutex); \/\/ \u4f7f\u7528 RAII \u7ba1\u7406\u9501，\u907f\u514d\u624b\u52a8\u89e3\u9501
\n while (_tasks.empty() && _isRunning)
\n {
\n _Slaves_Sleep_Count++;
\n _cond.Wait(_mutex);
\n _Slaves_Sleep_Count–;
\n }<\/p>\n
if (!_isRunning && _tasks.empty())
\n {
\n \/\/ \u9000\u51fa\u524d\u89e3\u9501（LockGuard \u6790\u6784\u65f6\u4f1a\u81ea\u52a8\u89e3\u9501，\u65e0\u9700\u624b\u52a8）
\n break;
\n }<\/p>\n
task = _tasks.front();
\n _tasks.pop();
\n }<\/p>\n
Log(LogLevel::INFO) << name << "\u5904\u7406\u4efb\u52a1:";
\n task();
\n \/\/ Log(LogLevel::DEBUG) << task.Result();
\n }
\n Log(LogLevel::INFO) << name << " quit…";
\n }<\/p>\n
\/\/ \u6784\u9020\u51fd\u6570\u79c1\u6709，\u7981\u6b62\u5916\u90e8\u76f4\u63a5\u521b\u5efa
\n threadpool(int slave_num = default_thread_num)
\n : _isRunning(false), _Slavernum(slave_num), _Slaves_Sleep_Count(0)
\n {
\n _Slaves.reserve(_Slavernum);
\n auto fun = std::bind(&threadpool::HandlerTask, this);
\n for (size_t i = 0; i < _Slavernum; ++i)
\n {
\n _Slaves.emplace_back(fun);
\n }
\n }<\/p>\n
\/\/ \u7981\u6b62\u62f7\u8d1d\u548c\u8d4b\u503c（\u4fee\u6b63：\u7c7b\u540d\u5e94\u4e3a threadpool）
\n threadpool(const threadpool &) = delete;
\n threadpool &operator=(const threadpool &) = delete;<\/p>\n
public:
\n static threadpool<T>* Instance()
\n {
\n if (_instance == nullptr)
\n {
\n LockModule::LockGuard lockguard(_lock);
\n if (_instance == nullptr)
\n {
\n \/\/ \u4f7f\u7528 reset(new …) \u66ff\u4ee3 std::make_unique，\u56e0\u4e3a\u6784\u9020\u51fd\u6570\u79c1\u6709
\n _instance.reset(new threadpool<T>());
\n _instance->Init(); \/\/ \u8c03\u7528 Init \u800c\u975e Start
\n Log(LogLevel::INFO) << "\u7b2c\u4e00\u6b21\u4f7f\u7528\u7ebf\u7a0b\u6c60，\u521b\u5efa\u7ebf\u7a0b\u6c60\u5bf9\u8c61";
\n }
\n }
\n return _instance.get();
\n }<\/p>\n
~threadpool()
\n {
\n }<\/p>\n
void Init()
\n {
\n if (_isRunning)
\n {
\n Log(LogLevel::WARNING) << "\u7ebf\u7a0b\u6c60\u5df2\u7ecf\u8fd0\u884c";
\n return;
\n }
\n _isRunning = true;
\n for (auto &slave : _Slaves)
\n {
\n slave.Start();
\n }
\n }<\/p>\n
void Stop()
\n {
\n if (!_isRunning)
\n {
\n Log(LogLevel::WARNING) << "\u7ebf\u7a0b\u6c60\u672a\u8fd0\u884c";
\n return;
\n }
\n \/\/ \u505c\u6b62\u7ebf\u7a0b\u6c60
\n _mutex.Lock();
\n _isRunning = false;
\n if (_Slaves_Sleep_Count > 0)
\n _cond.Broadcast();
\n _mutex.Unlock();<\/p>\n
\/\/ \u7b49\u5f85\u6240\u6709\u7ebf\u7a0b\u9000\u51fa（\u53ef\u9009）
\n \/\/ Wait();
\n }<\/p>\n
void Wait()
\n {
\n for (auto &slave : _Slaves)
\n {
\n slave.Join();
\n }
\n }<\/p>\n
void Enqueue(T in)
\n {
\n _mutex.Lock();
\n _tasks.push(in);
\n if (_Slaves_Sleep_Count > 0)
\n _cond.Signal();
\n _mutex.Unlock();
\n }<\/p>\n
private:
\n bool _isRunning;
\n size_t _Slavernum;
\n std::vector<Thread> _Slaves;
\n std::queue<T> _tasks; \/\/ \u4e34\u754c\u8d44\u6e90
\n LockModule::Mutex _mutex;
\n CondModule::Cond _cond;
\n size_t _Slaves_Sleep_Count; \/\/ \u4f11\u7720\u7684\u7ebf\u7a0b\u6570\u91cf<\/p>\n
\/\/ \u5355\u4f8b\u6a21\u5f0f\u9759\u6001\u6210\u5458
\n static std::unique_ptr<threadpool<T>> _instance;
\n static LockModule::Mutex _lock; \/\/ \u7c7b\u578b\u6539\u4e3a LockModule::Mutex
\n };<\/p>\n
\/\/ \u9759\u6001\u6210\u5458\u5b9a\u4e49（\u5fc5\u987b\u653e\u5728\u547d\u540d\u7a7a\u95f4\u5185）
\n template<typename T>
\n std::unique_ptr<threadpool<T>> threadpool<T>::_instance = nullptr;<\/p>\n
template<typename T>
\n LockModule::Mutex threadpool<T>::_lock;<\/p>\n
} \/\/ namespace ThreadPool <\/p>\n
#pragma once
\n#include<iostream>
\n#include<string>
\n#include<cstring>
\n#include <sys\/socket.h>
\n#include <netinet\/in.h>
\n#include <arpa\/inet.h>
\n\/\/\u7f51\u7edc\u5ba2\u6237\u7aef\u5c01\u88c5
\nclass InetAddr
\n{
\n private:
\n std::string IP_;
\n uint16_t port_;
\n struct sockaddr_in address_;
\n socklen_t len_;
\n public:
\n InetAddr()=default;
\n InetAddr(const struct sockaddr_in& address) : address_(address),len_(sizeof(address))
\n {
\n IP_ = inet_ntoa(address_.sin_addr); \/\/ \u5c06\u4e8c\u8fdb\u5236IP\u8f6c\u6362\u4e3a\u5b57\u7b26\u4e32
\n port_ = ntohs(address_.sin_port); \/\/ \u7aef\u53e3\u8f6c\u6362\u6b63\u786e
\n }
\n InetAddr(uint16_t port,const std::string ip="0.0.0.0"):IP_(ip),port_(port)
\n {
\n bzero(&address_, sizeof(address_));
\n address_.sin_family = AF_INET;
\n address_.sin_addr.s_addr = inet_addr(IP_.c_str());
\n address_.sin_port = htons(port_);
\n len_=sizeof(address_);
\n }
\n struct sockaddr_in*GetNetAddress()
\n {
\n return &address_;
\n }
\n ~InetAddr()=default;
\n socklen_t len()
\n {
\n return len_;
\n }
\n bool operator==(const InetAddr&addrs)
\n {
\n return (this-> IP_==addrs.IP_)&&(this->port_==addrs.port_);
\n }
\n std::string ToString()
\n {
\n return "[" + IP_ + ":" + std::to_string(port_) + "]";
\n }<\/p>\n
};<\/p>\n
#pragma once<\/p>\n
#include <iostream>
\n#include <cstdio>
\n#include <vector>
\n#include <string>
\n#include <cstdio>
\n#include <sys\/types.h>
\n#include <pwd.h>
\n#include <unistd.h><\/p>\n
class Command
\n{
\nprivate:
\n void LoadCommand()
\n {
\n _whitelist.emplace_back("ls -a -l");
\n _whitelist.emplace_back("ls -l");
\n _whitelist.emplace_back("pwd");
\n _whitelist.emplace_back("whoami");
\n _whitelist.emplace_back("who");
\n _whitelist.emplace_back("ps -al");
\n _whitelist.emplace_back("netstat -nltp");
\n _whitelist.emplace_back("netstat -nutp");
\n _whitelist.emplace_back("netstat -natp");
\n _whitelist.emplace_back("netstat -naup");
\n }
\n bool IsSafe(const std::string &cmd)
\n {
\n for (auto &elem : _whitelist)
\n {
\n if (elem == cmd)
\n return true;
\n }
\n return false;
\n }<\/p>\n
public:
\n Command()
\n {
\n LoadCommand();
\n }
\n ~Command() {}
\n \/\/ rm *.c *.cc *.hpp
\n \/\/ rm move
\n \/\/ ls -al && rm -rf \/
\n std::string Excute(const std::string &cmd)
\n {
\n if (!IsSafe(cmd))
\n {
\n return "bad man!";
\n }<\/p>\n
FILE *fp = popen(cmd.c_str(), "r");
\n if (fp == nullptr)
\n return "execute error!";
\n std::string result;
\n char buffer[1024];
\n while (fgets(buffer, sizeof(buffer), fp))
\n {
\n result += buffer;
\n }<\/p>\n
pclose(fp);<\/p>\n
return result;
\n }
\n std::string GetCommandString()
\n {
\n \/\/ whb@iv-ye4ege8iyo5i3z3clix9:~$<\/p>\n
struct passwd *pw = getpwuid(getuid());
\n std::string username = (pw?pw->pw_name : "unknown");<\/p>\n
char hostname[256];
\n if (gethostname(hostname, sizeof(hostname)) != 0)
\n {
\n snprintf(hostname, sizeof(hostname), "unknown");
\n }<\/p>\n
char cwd[1024];
\n if (getcwd(cwd, sizeof(cwd)) == NULL)
\n {
\n snprintf(cwd, sizeof(cwd), "unknown");
\n }<\/p>\n
return "[" + username + "@" + hostname + " " + cwd + "]# ";
\n }<\/p>\n
private:
\n std::vector<std::string> _whitelist;
\n}; <\/p>\n
#pragma once<\/p>\n
#include "Log.h"
\n#include "InetAddr.h"
\n#include "ThreadPool\/ThreadPool.hpp"
\n#include "Command.hpp" \/\/ \u65b0\u589e：\u5305\u542b Command \u7c7b
\n#include <unistd.h>
\n#include <functional>
\n#include <memory> \/\/ \u65b0\u589e：std::unique_ptr<\/p>\n
using namespace Logger;
\nusing namespace ThreadPool;<\/p>\n
using task_t = std::function<void()>;
\nusing handler_t = std::function<std::string(std::string)>;<\/p>\n
enum
\n{
\n SUCCESS = 0,
\n SOCKET_ERR,
\n BIND_ERR,
\n LISTEN_ERR,
\n USAGE_ERR
\n};<\/p>\n
static const int gblocklist = 16;
\nstatic const uint16_t defaultport = 8080;<\/p>\n
class TCPServer
\n{
\nprivate:
\n uint16_t port_;
\n int ListenSocketfd_;
\n handler_t hanlder_;
\n std::unique_ptr<Command> cmd_; \/\/ \u65b0\u589e：\u6301\u6709 Command \u5bf9\u8c61<\/p>\n
public:
\n TCPServer(uint16_t port = defaultport) : port_(port) {}<\/p>\n
void Init()
\n {
\n ListenSocketfd_ = socket(AF_INET, SOCK_STREAM, 0);
\n if (ListenSocketfd_ < 0)
\n {
\n Log(LogLevel::ERROR) << "\u670d\u52a1\u5668\u521b\u5efa\u5957\u63a5\u5b57\u5931\u8d25";
\n exit(SOCKET_ERR);
\n }
\n Log(LogLevel::DEBUG) << "\u521b\u5efa\u5957\u63a5\u5b57\u6210\u529f" << ListenSocketfd_;<\/p>\n
struct sockaddr_in local;
\n memset(&local, 0, sizeof(local));
\n local.sin_family = AF_INET;
\n local.sin_port = htons(port_);
\n local.sin_addr.s_addr = INADDR_ANY;<\/p>\n
int n = bind(ListenSocketfd_, (struct sockaddr *)&local, sizeof(local));
\n if (n < 0)
\n {
\n Log(LogLevel::ERROR) << "\u7ed1\u5b9a\u5931\u8d25";
\n exit(BIND_ERR);
\n }
\n Log(LogLevel::DEBUG) << "\u7ed1\u5b9a\u6210\u529f";<\/p>\n
int m = listen(ListenSocketfd_, gblocklist);
\n if (m < 0)
\n {
\n Log(LogLevel::ERROR) << "\u76d1\u542c\u5931\u8d25";
\n exit(LISTEN_ERR);
\n }
\n Log(LogLevel::DEBUG) << "\u76d1\u542c\u6210\u529f";
\n }<\/p>\n
\/\/ \u65b0\u589e：\u8bbe\u7f6e Command \u5bf9\u8c61（\u6240\u6709\u6743\u8f6c\u79fb）
\n void SetCommand(std::unique_ptr<Command> cmd)
\n {
\n cmd_ = std::move(cmd);
\n }<\/p>\n
\/\/ \u65b0\u589e：\u83b7\u53d6\u539f\u59cb\u6307\u9488\u4f9b lambda \u4f7f\u7528
\n Command* GetCommand() const
\n {
\n return cmd_.get();
\n }<\/p>\n
void Register(handler_t handler)
\n {
\n hanlder_ = handler;
\n }<\/p>\n
void ServerIO(int fd, InetAddr address)
\n {
\n Log(LogLevel::DEBUG) << "\u5ba2\u6237\u7aef\u4fe1\u606f" << address.ToString();
\n while (1)
\n {
\n \/\/ \u65b0\u589e：\u53d1\u9001\u547d\u4ee4\u63d0\u793a\u7b26
\n std::string prompt = cmd_->GetCommandString();
\n ssize_t sent = write(fd, prompt.c_str(), prompt.size());
\n if (sent <= 0)
\n {
\n Log(LogLevel::WARNING) << "\u53d1\u9001\u63d0\u793a\u7b26\u5931\u8d25，\u5173\u95ed\u8fde\u63a5";
\n break;
\n }<\/p>\n
char inbuffer[1024] = {0};
\n ssize_t n = read(fd, inbuffer, sizeof(inbuffer) – 1);
\n if (n > 0)
\n {
\n inbuffer[n] = 0;
\n std::string result;
\n if (hanlder_ != nullptr)
\n {
\n result = hanlder_(inbuffer);
\n }
\n else
\n {
\n Log(LogLevel::WARNING) << "\u670d\u52a1\u6ca1\u6709\u51c6\u5907\u597d";
\n break;
\n }
\n write(fd, result.c_str(), result.size());
\n }
\n else if (n == 0)
\n {
\n Log(LogLevel::INFO) << "\u5ba2\u6237\u7aef\u9000\u51fa" << address.ToString();
\n break;
\n }
\n else
\n {
\n Log(LogLevel::WARNING) << "\u5ba2\u6237\u7aef\u51fa\u9519" << address.ToString();
\n break;
\n }
\n }
\n }<\/p>\n
class ThreadData
\n {
\n public:
\n ThreadData(TCPServer *ts, int sockfd, InetAddr addr)
\n : _this(ts), _sockfd(sockfd), _addr(addr)
\n {}
\n ~ThreadData() {}
\n public:
\n TCPServer *_this;
\n int _sockfd;
\n InetAddr _addr;
\n };<\/p>\n
void Start()
\n {
\n while (1)
\n {
\n struct sockaddr_in clientaddr;
\n socklen_t len = sizeof(clientaddr);
\n int socketfd = accept(ListenSocketfd_, (struct sockaddr *)&clientaddr, &len);
\n if (socketfd < 0)
\n {
\n Log(LogLevel::WARNING) << "\u76d1\u542c\u5931\u8d25";
\n continue;
\n }
\n Log(LogLevel::DEBUG) << "\u76d1\u542c\u6210\u529f";<\/p>\n
InetAddr clientaddress(clientaddr);
\n threadpool<task_t>::Instance()->Enqueue([this, socketfd, clientaddress]() {
\n this->ServerIO(socketfd, clientaddress);
\n });
\n }
\n }<\/p>\n
~TCPServer()
\n {
\n close(ListenSocketfd_);
\n }
\n}; <\/p>\n
#include "TCPServer.hpp"
\n#include "Command.hpp"
\n#include <memory>
\n#include <cstdlib><\/p>\n
inline static void Usage(const std::string &proc)
\n{
\n std::cerr << "\u8f93\u5165\u9519\u8bef\\\\n\\\\t";
\n std::cerr << proc << "\u4f60\u5e94\u8be5\u544a\u8bc9\u6211\u4f60\u7684\u7aef\u53e3\u53f7" << std::endl;
\n}<\/p>\n
int main(int argc, char *argv[])
\n{
\n if (argc != 2)
\n {
\n Usage(argv[0]);
\n exit(USAGE_ERR);
\n }
\n ENABLE_LOG_CONSOLE();<\/p>\n
uint16_t port = std::atoi(argv[1]);<\/p>\n
\/\/ \u521b\u5efa Command \u5bf9\u8c61
\n auto cmd = std::make_unique<Command>();<\/p>\n
\/\/ \u521b\u5efa TCPServer \u5bf9\u8c61
\n auto tsvr = std::make_unique<TCPServer>(port);<\/p>\n
\/\/ \u5c06 Command \u6240\u6709\u6743\u8f6c\u79fb\u7ed9 TCPServer
\n tsvr->SetCommand(std::move(cmd));<\/p>\n
\/\/ \u6ce8\u518c\u547d\u4ee4\u5904\u7406\u51fd\u6570（\u4f7f\u7528 TCPServer \u5185\u90e8\u7684 Command \u5bf9\u8c61）
\n tsvr->Register([cmd_ptr = tsvr->GetCommand()](std::string command) {
\n return cmd_ptr->Excute(command);
\n });<\/p>\n
tsvr->Init();
\n tsvr->Start();<\/p>\n
return 0;
\n} <\/p>\n
#include <iostream>
\n#include <string>
\n#include <cstdlib>
\n#include <unistd.h>
\n#include <sys\/socket.h>
\n#include <arpa\/inet.h>
\n#include <netinet\/in.h>
\n#include "InetAddr.h"<\/p>\n
static void Usage(const std::string &name)
\n{
\n std::cerr << "Usage:\\\\n\\\\t";
\n std::cerr << name << " server_ip server_port" << std::endl;
\n}<\/p>\n
\/\/ .\/client_tcp server_ip server_port
\nint main(int argc, char *argv[])
\n{
\n if (argc != 3)
\n {
\n Usage(argv[0]);
\n exit(1);
\n }
\n std::string server_ip = argv[1];
\n uint16_t server_port = std::stoi(argv[2]);
\n \/\/ 1. \u521b\u5efatcpsocket\u5957\u63a5\u5b57
\n int sockfd = socket(AF_INET, SOCK_STREAM, 0);
\n if (sockfd < 0)
\n {
\n std::cerr << "socket error" << std::endl;
\n exit(2);
\n }<\/p>\n
\/\/ 2. \u8981\u4e0d\u8981\u8fdb\u884cbind？\u9700\u8981
\n \/\/ \u8981\u4e0d\u8981\u663e\u793a\u7684bind\u672c\u5730IP\u548c\u7aef\u53e3？\u4e0d\u9700\u8981\u81ea\u5df1\u624b\u52a8\u663e\u793a\u7684\u8fdb\u884cbind，OS\u4f1a\u81ea\u52a8bind\u7684！
\n \/\/ OS \u5e2e\u52a9\u6211\u4eec\u8fdb\u884c\u968f\u673a\u7aef\u53e3，\u9632\u6b62\u7aef\u53e3\u53f7\u51b2\u7a81
\n \/\/ 2. \u5e94\u8be5\u5e72\u4ec0\u4e48？bind\u7aef\u53e3\u53f7ip，\u53d1\u8d77\u5efa\u7acb\u8fde\u63a5\u7684\u5de5\u4f5c
\n \/\/ {client ip, client port} <-> {server ip, server port}
\n InetAddr serveraddress(server_port, server_ip);
\n int n = connect(sockfd, (struct sockaddr *)serveraddress.GetNetAddress(), serveraddress.len());
\n if (n < 0)
\n {
\n std::cerr << "connect to " << serveraddress.ToString() << " failed!"<< std::endl;
\n exit(3);
\n }
\n std::cerr << "connect to " << serveraddress.ToString() << " success!" << std::endl;<\/p>\n
\/\/ 3. \u901a\u4fe1
\n while(true)
\n {
\n char commandline[1024];
\n std::string commandlinestr;
\n ssize_t n = read(sockfd, commandline, sizeof(commandline)-1);
\n if(n > 0)
\n {
\n commandline[n] = 0;
\n commandlinestr = commandline;
\n }
\n else{
\n commandlinestr = "[unknow@unknown None]# ";
\n }<\/p>\n
std::cout << commandlinestr;<\/p>\n
\/\/ \u5904\u7406\u4e00\u4e2a\u547d\u4ee4
\n std::string command;
\n std::getline(std::cin, command);
\n write(sockfd, command.c_str(), command.size());<\/p>\n
char inbuffer[1024];
\n n = read(sockfd, inbuffer, sizeof(inbuffer));
\n if(n > 0)
\n {
\n inbuffer[n] = 0;
\n std::cout << inbuffer << std::endl;
\n }
\n else if(n == 0)
\n {
\n std::cout << "read enf of file!" << std::endl;
\n break;
\n }
\n else
\n {
\n std::cerr << "read error!" << std::endl;
\n break;
\n }
\n }<\/p>\n
return 0;
\n} <\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u8de8\u7f51\u7edc\u8fde\u63a5，\u7ed3\u679c\u4e3a：<\/p>\n
<\/p>\n<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u5173\u4e8eTCP\u7f51\u7edc\u7684\u5185\u5bb9，\u5230\u8fd9\u91cc\u5c31\u7ed3\u675f\u4e86，\u559c\u6b22\u8bf7\u70b9\u4e2a\u8d5e，\u8c22\u8c22<\/p>\n
\u5c01\u9762\u56fe\u81ea\u53d6：<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/03\/20260303115055-69a6cb1f32ff8.png\")
<\/p>\n","protected":false},"excerpt":{"rendered":"
\u524d\u9762\u6211\u4eec\u57fa\u4e8eTCP\u5b9e\u73b0\u4e86\u7b80\u5355\u4e86\u4e92\u52a8\u670d\u52a1\u5668\u3002\u4f46\u662f\u90a3\u662f\u8fdc\u8fdc\u4e0d\u591f\u7684，\u672c\u671f\u6211\u4eec\u5c06\u5b9e\u73b0\u4e00\u4e2a\u57fa\u4e8eTCP\u7684\u8fdc\u7a0b\u547d\u4ee4\u884c\u7ec8\u7aef \u76f8\u5173\u4ee3\u7801\u63d0\u4ea4\u81f3\u4f5c\u8005\u7684\u4e2a\u4ebagitee：\u697c\u7530\u8389\u5b50\/Linux\u5b66\u4e60\u559c\u6b22\u8bf7\u70b9\u4e2a\u8d5e\u8c22\u8c22
\n\u76ee\u5f55
\n\u65e5\u5fd7
\n\u7ebf\u7a0b\u6c60\u76f8\u5173
\n\u7f51\u7edc\u5ba2\u6237\u7aef
\n\u547d\u4ee4
\n\u670d\u52a1\u5668 \u670d\u52a1\u5668\u4ee3\u7801 \u670d\u52a1\u5668\u8fd0\u884c \u5ba2\u6237\u7aef\u8fd0\u884c \u6d4b\u8bd5 \u65e5\u5fd7
\n#pragma once#include
\n#include
\n#include
\n#inclu<\/p>\n","protected":false},"author":2,"featured_media":79938,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[55,58,205,371,190,78],"topic":[],"class_list":["post-79940","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-c","tag-linux","tag-tcp-ip","tag-371","tag-190","tag-78"],"yoast_head":"\n