devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

一个简易的基于线程池的TCP的任务处理

作者：知新_RL | 2024-03-23 07:46:28

赞

踩

一个简易的基于线程池的TCP的任务处理
  • 基于队列的线程池
  1. #pragma once
  2. #include <iostream>
  3. #include <cassert>
  4. #include <queue>
  5. #include <pthread.h>
  6. #include <sys/prctl.h>
  7. #include "Log.hpp"
  8. #include "Lock.hpp"
  9. #include "Task.hpp"
  10.  
  11. using namespace std;
  12.  
  13. const int gThreadNum = 5;
  14.  
  15. template <class T>
  16. class threadPool
  17. {
  18. private:
  19.     threadPool(int num = gThreadNum) : threadNums(num), isStart(false)
  20.     {
  21.         assert(threadNums > 0);
  22.         // 初始化互斥锁和条件变量
  23.         pthread_mutex_init(&mutex, nullptr);
  24.         pthread_cond_init(&cond, nullptr);
  25.     }
  26.     // 单例模式  禁止拷贝构造和赋值操作
  27.     threadPool(const threadPool<T> &t) = delete;
  28.     threadPool<T> operator=(const threadPool<T> &t) = delete;
  29.  
  30. public:
  31.     // 懒汉模式
  32.     static threadPool<T> *getInstance()
  33.     {
  34.         // 初始化锁
  35.         static Mutex m;
  36.         if (nullptr == instance) // 双重判定空指针, 降低锁冲突的概率, 提高性能。
  37.         {
  38.             // RAII思想
  39.             GuardLock guard(&m);
  40.             if (nullptr == instance)
  41.                 instance = new threadPool<T>();
  42.         }
  43.         return instance;
  44.     }
  45.  
  46.     ~threadPool()
  47.     {
  48.         pthread_mutex_destroy(&mutex);
  49.         pthread_cond_destroy(&cond);
  50.     }
  51.  
  52.     // 线程启动后执行的函数  传入了this指针
  53.     static void *taskRoutine(void *args)
  54.     {
  55.         pthread_detach(pthread_self()); // 分离线程  自动回收
  56.         threadPool<T> *tp = static_cast<threadPool<T> *>(args);
  57.         // prctl(PR_SET_NAME, "follower");//修改线程名称
  58.         while (1)
  59.         {
  60.             // 队列中拿取任务
  61.             tp->lockQueue();
  62.             while (!tp->haveTask())
  63.             {
  64.                 // 等待条件信号量
  65.                 tp->waitForTask();
  66.             }
  67.             T t = tp->pop();
  68.             tp->unlockQueue();
  69.             t(); // 让指定的线程执行任务
  70.         }
  71.     }
  72.  
  73.     void start()
  74.     {
  75.         assert(!isStart);
  76.         // 根据线程池中的线程数量创建线程
  77.         for (size_t i = 0; i < threadNums; i++)
  78.         {
  79.             pthread_t temp; // 输出型参数  线程ID
  80.             pthread_create(&temp, nullptr, taskRoutine, this);
  81.         }
  82.         isStart = true;
  83.     }
  84.  
  85.     // 添加任务
  86.     void push(const T &in)
  87.     {
  88.         lockQueue();
  89.         taskQueue.push(in);
  90.         // 唤醒条件信号量  任务队列里面来任务了，线程可以开始处理任务了
  91.         choiceThreadForHandler();
  92.         unlockQueue();
  93.     }
  94.  
  95.     int getThreadNum()
  96.     {
  97.         return threadNums;
  98.     }
  99.  
  100. private:
  101.     void lockQueue() { pthread_mutex_lock(&mutex); }
  102.     void unlockQueue() { pthread_mutex_unlock(&mutex); }
  103.     bool haveTask() { return !taskQueue.empty(); }
  104.     void waitForTask() { pthread_cond_wait(&cond, &mutex); }
  105.     void choiceThreadForHandler() { pthread_cond_signal(&cond); }
  106.  
  107.     // 获取任务
  108.     T pop()
  109.     {
  110.         T temp = taskQueue.front();
  111.         taskQueue.pop();
  112.         return temp;
  113.     }
  114.  
  115. private:
  116.     bool isStart;
  117.     int threadNums;
  118.     queue<T> taskQueue;
  119.     pthread_mutex_t mutex;
  120.     pthread_cond_t cond;
  121.  
  122.     static threadPool<T> *instance;
  123. };
  124.  
  125. template <class T>
  126. threadPool<T> *threadPool<T>::instance;
  • 简单的任务类（通过回调函数创建并处理任务）
  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <functional>
  5. #include "Log.hpp"
  6.  
  7. using namespace std;
  8.  
  9. class task
  10. {
  11. public:
  12.     // 创建函数对象
  13.     using called_func = function<void(int, string, uint16_t)>;
  14.  
  15.     task(int s, string i, int p, called_func f) : sock(s), ip(i), port(p), func(f) {}
  16.     ~task() {}
  17.  
  18.     // 重载operator()
  19.     void operator()()
  20.     {
  21.         LogMessage(DEBUG, "线程ID[%p]处理%s:%d的请求 开始啦...", pthread_self(), ip.c_str(), port);
  22.         func(sock, ip, port);
  23.         LogMessage(DEBUG, "线程ID[%p]处理%s:%d的请求 结束啦...", pthread_self(), ip.c_str(), port);
  24.     }
  25.  
  26. private:
  27.     string ip;
  28.     uint16_t port;
  29.     int sock;
  30.     called_func func; // 回调函数
  31. };
  • 工具类（互斥锁类、打印日志文件类、创建守护进程类） 
    1. #include <iostream>
    2. #include <pthread.h>
    3.  
    4. using namespace std;
    5.  
    6. class Mutex
    7. {
    8. public:
    9.     Mutex()
    10.     {
    11.         pthread_mutex_init(&_lock, nullptr);
    12.     }
    13.  
    14.     void lock()
    15.     {
    16.         pthread_mutex_lock(&_lock);
    17.     }
    18.  
    19.     void unlock()
    20.     {
    21.         pthread_mutex_unlock(&_lock);
    22.     }
    23.  
    24.     ~Mutex()
    25.     {
    26.         pthread_mutex_destroy(&_lock);
    27.     }
    28.  
    29. private:
    30.     pthread_mutex_t _lock;
    31. };
    32.  
    33. class GuardLock
    34. {
    35. public:
    36.     GuardLock(Mutex *mutex) : _mutex(mutex)
    37.     {
    38.         _mutex->lock();
    39.         cout << "加锁成功..." << endl;
    40.     }
    41.  
    42.     ~GuardLock()
    43.     {
    44.         _mutex->unlock();
    45.         cout << "解锁成功..." << endl;
    46.     }
    47.  
    48. private:
    49.     Mutex *_mutex;
    50. };
    1. #pragma once
    2.  
    3. #include <cassert>
    4. #include <cstdarg>
    5. #include <cstring>
    6. #include <ctime>
    7. #include <cerrno>
    8. #include <stdio.h>
    9. #include <stdlib.h>
    10. #include <sys/types.h>
    11. #include <sys/stat.h>
    12. #include <fcntl.h>
    13. #include <unistd.h>
    14.  
    15. #define DEBUG 0
    16. #define NOTICE 1
    17. #define WARINING 2
    18. #define FATAL 3
    19.  
    20. #define LOGFILE "serverTcp.log"
    21.  
    22. const char *log_level[] = {"DEBUG", "NOTICE", "WARINING", "FATAL"};
    23.  
    24. // 创建serverTcp.log日志文件  将控制台输出全部重定向到文件中
    25. // 在Log类对象被销毁时，进行刷盘操作
    26. class Log
    27. {
    28. public:
    29.     Log() : logFd(-1)
    30.     {
    31.     }
    32.     void enable()
    33.     {
    34.         umask(0);
    35.         logFd = open(LOGFILE, O_WRONLY | O_CREAT | O_APPEND, 0666);
    36.         assert(logFd > 0);
    37.         dup2(logFd, 1);
    38.         dup2(logFd, 2);
    39.     }
    40.     ~Log()
    41.     {
    42.         if (logFd > 0)
    43.         {
    44.             fsync(logFd);
    45.             close(logFd);
    46.         }
    47.     }
    48.  
    49. private:
    50.     int logFd;
    51. };
    52.  
    53. // 打印日志信息
    54. void LogMessage(int level, const char *format, ...)
    55. {
    56.     assert(level >= DEBUG);
    57.     assert(level <= FATAL);
    58.  
    59.     char *name = getenv("USER");
    60.  
    61.     char buff[1024];
    62.     va_list v;
    63.     va_start(v, format);
    64.  
    65.     vsnprintf(buff, sizeof(buff) - 1, format, v);
    66.  
    67.     va_end(v);
    68.  
    69.     FILE *out = (level == FATAL) ? stderr : stdout;
    70.  
    71.     // umask(0);
    72.     // int fd = open(LOGFILE, O_WRONLY | O_CREAT | O_APPEND, 0666);
    73.     // assert(fd > 0);
    74.  
    75.     fprintf(out, "%s | %u | %s | %s\n",
    76.             log_level[level],
    77.             (unsigned int)time(nullptr),
    78.             name == nullptr ? "unknow" : name,
    79.             buff);
    80.  
    81.     // dup2(fd, 1);
    82.     // dup2(fd, 2);
    83.  
    84.     fflush(out);
    85.  
    86.     // fsync(fd);
    87.  
    88.     // close(fd);
    89. }
    1. #include <signal.h>
    2. #include <unistd.h>
    3. #include <stdlib.h>
    4. #include <sys/types.h>
    5. #include <sys/stat.h>
    6. #include <fcntl.h>
    7.  
    8. void daemonize()
    9. {
    10.     // 打开linux的垃圾桶
    11.     int fd = open("/dev/null", O_WRONLY);
    12.     // 忽略SIGPIPE
    13.     signal(SIGPIPE, SIG_IGN);
    14.     // 创建子进程，然后关闭其父进程
    15.     if (fork() > 0)
    16.         exit(1);
    17.     //将由BASH 1号进程接管的子进程设置成为独立会话
    18.     setsid();
    19.     
    20.     if (fd != -1)
    21.     {
    22.         dup2(fd, 0);
    23.         dup2(fd, 1);
    24.         dup2(fd, 2);
    25.         if (fd > 2)
    26.             close(fd);
    27.     }
    28. }
    1. #pragma once
    2.  
    3. #include <iostream>
    4. #include <string>
    5. #include <cstring>
    6. #include <cstdlib>
    7. #include <cassert>
    8. #include <ctype.h>
    9. #include <unistd.h>
    10. #include <strings.h>
    11. #include <sys/types.h>
    12. #include <sys/socket.h>
    13. #include <netinet/in.h>
    14. #include <arpa/inet.h>
    15.  
    16. using namespace std;
    17.  
    18. #define SOCKET_ERR 1
    19. #define BIND_ERR   2
    20. #define LISTEN_ERR 3
    21. #define USAGE_ERR  4
    22. #define CONN_ERR   5
    23.  
    24. #define BUFFER_SIZE 1024

    TCPserver端

    1. #include "util.hpp"
    2. #include "Log.hpp"
    3. #include "ThreadPool.hpp"
    4. #include "daemonize.hpp"
    5. #include <signal.h>
    6. #include <sys/types.h>
    7. #include <sys/wait.h>
    8. #include <pthread.h>
    9.  
    10. class Server;
    11.  
    12. class ThreadData
    13. {
    14. public:
    15.     uint16_t clientPort_;
    16.     std::string clinetIp_;
    17.     int sock_;
    18.     Server *this_;
    19.  
    20. public:
    21.     ThreadData(uint16_t port, std::string ip, int sock, Server *ts)
    22.         : clientPort_(port), clinetIp_(ip), sock_(sock), this_(ts)
    23.     {
    24.     }
    25. };
    26.  
    27. // 创建task时的传入函数
    28. void transService(int sock, const string &ip, int port)
    29. {
    30.     assert(sock >= 0);
    31.     assert(!ip.empty());
    32.     assert(port >= 1024);
    33.     char buffer[BUFFER_SIZE];
    34.     while (true)
    35.     {
    36.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    37.         if (s > 0)
    38.         {
    39.             buffer[s] = '\0';
    40.             if (strcasecmp(buffer, "quit") == 0)
    41.             {
    42.                 LogMessage(DEBUG, "client quit -- %s[%d]", ip.c_str(), port);
    43.                 break;
    44.             }
    45.             LogMessage(DEBUG, "trans before: %s[%d]>>> %s", ip.c_str(), port, buffer);
    46.             for (int i = 0; i < s; i++)
    47.             {
    48.                 if (isalpha(buffer[i]) && islower(buffer[i]))
    49.                     buffer[i] = toupper(buffer[i]);
    50.             }
    51.             LogMessage(DEBUG, "trans after: %s[%d]>>> %s", ip.c_str(), port, buffer);
    52.             write(sock, buffer, strlen(buffer));
    53.         }
    54.         else if (s == 0)
    55.         {
    56.             LogMessage(DEBUG, "client quit -- %s[%d]", ip.c_str(), port);
    57.             break;
    58.         }
    59.         else
    60.         {
    61.             LogMessage(DEBUG, "%s[%d] - read: %s", ip.c_str(), port, strerror(errno));
    62.             break;
    63.         }
    64.     }
    65.     close(sock);
    66.     LogMessage(DEBUG, "server close %d done", sock);
    67. }
    68. // 创建task时的传入函数
    69. void commandService(int sock, const string &ip, int port)
    70. {
    71.     assert(sock >= 0);
    72.     assert(!ip.empty());
    73.     assert(port >= 1024);
    74.     char buffer[BUFFER_SIZE];
    75.     while (true)
    76.     {
    77.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    78.         if (s > 0)
    79.         {
    80.             buffer[s] = 0;
    81.             LogMessage(DEBUG, "[%s:%d] exec [%s]", ip.c_str(), port, buffer);
    82.             FILE *f = popen(buffer, "r");
    83.             if (f == nullptr)
    84.             {
    85.                 LogMessage(WARINING, "exec %s failed, beacuse: %s", buffer, strerror(errno));
    86.             }
    87.             char line[1024];
    88.             while (fgets(line, sizeof(line), f) != nullptr)
    89.             {
    90.                 write(sock, line, sizeof(line));
    91.             }
    92.             pclose(f);
    93.             LogMessage(DEBUG, "[%s:%d] exec [%s] ... done", ip.c_str(), port, buffer);
    94.         }
    95.         else if (s == 0)
    96.         {
    97.             LogMessage(DEBUG, "client quit -- %s[%d]", ip.c_str(), port);
    98.             break;
    99.         }
    100.         else
    101.         {
    102.             LogMessage(DEBUG, "%s[%d] - read: %s", ip.c_str(), port, strerror(errno));
    103.             break;
    104.         }
    105.     }
    106.     close(sock);
    107.     LogMessage(DEBUG, "server close %d done", sock);
    108. }
    109.  
    110. class Server
    111. {
    112. public:
    113.     Server(int port, string ip = "") : port_(port), ip_(ip), listenSock_(-1) {}
    114.     ~Server() {}
    115.  
    116.     void init()
    117.     {
    118.         // 创建TCP套接字
    119.         listenSock_ = socket(AF_INET, SOCK_STREAM, 0);
    120.         if (listenSock_ < 0)
    121.         {
    122.             LogMessage(FATAL, "socket: %s", strerror(errno));
    123.             exit(SOCKET_ERR);
    124.         }
    125.         LogMessage(DEBUG, "socket success: %s , %d", strerror(errno), listenSock_);
    126.  
    127.         struct sockaddr_in local;
    128.         socklen_t len = sizeof(local);
    129.         memset(&local, 0, sizeof(local));
    130.         local.sin_port = htons(port_);
    131.         local.sin_family = PF_INET;
    132.         ip_.empty() ? (local.sin_addr.s_addr = INADDR_ANY) : (inet_aton(ip_.c_str(), &local.sin_addr));
    133.         // 绑定套接字
    134.         if (bind(listenSock_, (sockaddr *)&local, len) < 0)
    135.         {
    136.             LogMessage(FATAL, "bind: %s", strerror(errno));
    137.             exit(BIND_ERR);
    138.         }
    139.         LogMessage(DEBUG, "bind success : %s %d", strerror(errno), listenSock_);
    140.         // 监听套接字  最大连接数5
    141.         if (listen(listenSock_, 5) < 0)
    142.         {
    143.             LogMessage(FATAL, "listen: %s", strerror(errno));
    144.             exit(LISTEN_ERR);
    145.         }
    146.         LogMessage(DEBUG, "listen succcess: %s , %d", strerror(errno), listenSock_);
    147.  
    148.         // 加载线程池
    149.         tp = threadPool<task>::getInstance();
    150.     }
    151.  
    152.     // static void *thradRoutine(void *args)
    153.     // {
    154.     //     pthread_detach(pthread_self());
    155.     //     ThreadData *td = (ThreadData *)args;
    156.     //     td->this_->transService(td->sock_, td->clinetIp_, td->clientPort_);
    157.     //     delete td;
    158.     //     return nullptr;
    159.     // }
    160.  
    161.     void loop()
    162.     {
    163.         // signal(SIGCHLD, SIG_IGN);
    164.         // 初始化线程池 创建线程
    165.         tp->start();
    166.         LogMessage(DEBUG, "thread pool start success, thread num: %d", tp->getThreadNum());
    167.  
    168.         while (true)
    169.         {
    170.             struct sockaddr_in peer;
    171.             socklen_t len = sizeof(peer);
    172.             // 接收请求连接 serviceSock服务套接字
    173.             int serviceSock = accept(listenSock_, (sockaddr *)&peer, &len);
    174.             if (serviceSock < 0)
    175.             {
    176.                 LogMessage(WARINING, "accept: %s , %d", strerror(errno), serviceSock);
    177.                 continue;
    178.             }
    179.             uint16_t peerPort = ntohs(peer.sin_port);
    180.             string peerIp = inet_ntoa(peer.sin_addr);
    181.             LogMessage(DEBUG, "accept success: %s | %s[%d], socket fd: %d",
    182.                        strerror(errno), peerIp.c_str(), peerPort, serviceSock);
    183.  
    184.             // demo 5 线程池
    185.             //  5.1
    186.             //  task t(serviceSock, peerIp, peerPort, std::bind(&Server::transService, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
    187.             //  tp->push(t);
    188.             //  5.2
    189.             //  task t(serviceSock, peerIp, peerPort,transService);
    190.             //  tp->push(t);
    191.             //  5.3
    192.             // 创建任务
    193.             task t(serviceSock, peerIp, peerPort, commandService);
    194.             // 将任务放入任务队列中
    195.             tp->push(t);
    196.  
    197.             // demo 4 多线程
    198.             // ThreadData *td = new ThreadData(peerPort, peerIp, serviceSock, this);
    199.             // pthread_t pt;
    200.             // pthread_create(&pt, nullptr, thradRoutine, (void *)td);
    201.  
    202.             // demo3 多进程
    203.             // pid_t id = fork();
    204.             // if (id == 0)
    205.             // {
    206.             //     close(listenSock_);
    207.             //     if (fork() > 0)
    208.             //         exit(0);
    209.             //     transService(serviceSock, peerIp, peerPort);
    210.             //     exit(0);
    211.             // }
    212.             // close(serviceSock);
    213.             // pid_t ret = waitpid(id, nullptr, 0);
    214.             // assert(ret > 0);
    215.             // (void)ret;
    216.  
    217.             // demo2 多进程
    218.             // pid_t id = fork();
    219.             // if(id == 0){
    220.             //     close(listenSock_);
    221.             //     transService(serviceSock,peerIp,peerPort);
    222.             //     exit(0);
    223.             // }
    224.             // close(serviceSock);
    225.             // 通过signal(SIGCHLD,SIG_IGN)来处理僵尸子进程
    226.  
    227.             // demo 1
    228.             // transService(serviceSock, peerIp, peerPort);
    229.  
    230.             // LogMessage(DEBUG, "server 提供 service start ...");
    231.             // sleep(1);
    232.         }
    233.     }
    234.  
    235.     // 5.1
    236.     // void transService(int sock, const string &ip, int port)
    237.     // {
    238.     //     assert(sock >= 0);
    239.     //     assert(!ip.empty());
    240.     //     assert(port >= 1024);
    241.     //     char buffer[BUFFER_SIZE];
    242.     //     while (true)
    243.     //     {
    244.     //         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    245.     //         if (s > 0)
    246.     //         {
    247.     //             buffer[s] = '\0';
    248.     //             if (strcasecmp(buffer, "quit") == 0)
    249.     //             {
    250.     //                 LogMessage(DEBUG, "client quit -- %s[%d]", ip.c_str(), port);
    251.     //                 break;
    252.     //             }
    253.     //             LogMessage(DEBUG, "trans before: %s[%d]>>> %s", ip.c_str(), port, buffer);
    254.     //             for (int i = 0; i < s; i++)
    255.     //             {
    256.     //                 if (isalpha(buffer[i]) && islower(buffer[i]))
    257.     //                     buffer[i] = toupper(buffer[i]);
    258.     //             }
    259.     //             LogMessage(DEBUG, "trans after: %s[%d]>>> %s", ip.c_str(), port, buffer);
    260.     //             write(sock, buffer, strlen(buffer));
    261.     //         }
    262.     //         else if (s == 0)
    263.     //         {
    264.     //             LogMessage(DEBUG, "client quit -- %s[%d]", ip.c_str(), port);
    265.     //             break;
    266.     //         }
    267.     //         else
    268.     //         {
    269.     //             LogMessage(DEBUG, "%s[%d] - read: %s", ip.c_str(), port, strerror(errno));
    270.     //             break;
    271.     //         }
    272.     //     }
    273.     //     close(sock);
    274.     //     LogMessage(DEBUG, "server close %d done", sock);
    275.     // }
    276.  
    277. private:
    278.     uint16_t port_;
    279.     string ip_;
    280.     int listenSock_;
    281.     threadPool<task> *tp;
    282. };
    283.  
    284. static void Usage(string s)
    285. {
    286.     cout << "Usage: \n\t" << s << "port ip" << endl;
    287.     cout << "ex:    \n\t" << s << "8080 127.0.0.1" << endl;
    288. }
    289.  
    290. int main(int args, char *argv[])
    291. {
    292.     if (args != 2 && args != 3)
    293.     {
    294.         Usage(argv[0]);
    295.         exit(USAGE_ERR);
    296.     }
    297.     uint16_t p = atoi(argv[1]);
    298.     string i;
    299.     if (args == 3)
    300.         i = argv[2];
    301.  
    302.     daemonize();
    303.  
    304.     Log log;
    305.     log.enable();
    306.  
    307.     Server s(p, i);
    308.     s.init();
    309.     s.loop();
    310.  
    311.     return 0;
    312. }

    TCPclient端

    1. #include "util.hpp"
    2. #include "Log.hpp"
    3.  
    4. static void Usage(string s)
    5. {
    6.     cout << "Usage: \n\t" << s << "ip port" << endl;
    7.     cout << "ex:    \n\t" << s << "127.0.0.1 8080" << endl;
    8. }
    9.  
    10. volatile bool flag = false;
    11.  
    12. int main(int args, char *argv[])
    13. {
    14.     if (args != 3)
    15.     {
    16.         Usage(argv[0]);
    17.         exit(USAGE_ERR);
    18.     }
    19.     string ip = argv[1];
    20.     uint16_t port = atoi(argv[2]);
    21.  
    22.     // 创建套接字
    23.     int clientSock = socket(AF_INET, SOCK_STREAM, 0);
    24.     if (clientSock < 0)
    25.     {
    26.         cerr << "socket: " << strerror(errno) << endl;
    27.         exit(SOCKET_ERR);
    28.     }
    29.     struct sockaddr_in server;
    30.     memset(&server, 0, sizeof(server));
    31.     socklen_t len = sizeof(server);
    32.     server.sin_port = htons(port);
    33.     server.sin_family = AF_INET;
    34.     inet_aton(ip.c_str(), &server.sin_addr);
    35.  
    36.     // 请求连接
    37.     if (connect(clientSock, (const sockaddr *)&server, len) == -1)
    38.     {
    39.         cerr << "connect: " << strerror(errno) << endl;
    40.         exit(SOCKET_ERR);
    41.     }
    42.     cout << "info : connect success: " << clientSock << endl;
    43.  
    44.     // 与服务器开始通信
    45.     string message;
    46.     while (!flag)
    47.     {
    48.         message.clear();
    49.         cout << "Please Enter# ";
    50.         getline(cin, message);
    51.         if (strcasecmp(message.c_str(), "quit") == 0)
    52.             flag = true;
    53.         // 发送信息给服务器
    54.         ssize_t s = write(clientSock, message.c_str(), message.size());
    55.         // 发送成功
    56.         if (s > 0)
    57.         {
    58.             message.resize(1024);
    59.             // 读取服务器处理后发送过来的信息
    60.             ssize_t s = read(clientSock, (char *)(message.c_str()), 1024);
    61.             if (s > 0)
    62.                 message[s] = 0;
    63.             cout << "Server Echo>>> " << message << endl;
    64.         }
    65.         // 发送失败
    66.         else if (s <= 0)
    67.         {
    68.             break;
    69.         }
    70.     }
    71.     // 关闭套接字
    72.     close(clientSock);
    73.  
    74.     return 0;
    75. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/293959
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号