• 【Linux网络编程】Socket-TCP实例

    该代码利用socket套接字建立Tcp连接，包含服务器和客户端。当服务器和客户端启动时需要把端口号或ip地址以命令行参数的形式传入。服务器启动如果接受到客户端发来的请求连接，accept函数会返回一个打开的socket文件描述符，区别于监听连接的listensock，它用来为客户端提供服务的。因为有线程池的存在，可以立即使用已经创建好的线程来为客户端提供服务。线程池中存在一个数据结构专门用来存放客户端IP与端口信息，如果没有新的客户端连接服务器，那么该数据结构内容为空，那么多余的线程就会因为没有用户连接而阻塞，直到新用户的到来。以上就是对代码的大概介绍了。

    下面是关于代码的六点细节解释：

    1.查看网络连接 

      netstat  -nltp

    2.可以用read函数读取TCP套接字的数据，而UDP不行。因为UDP是面向数据报，而TCP是面向数据流。所以代码使用了read与write函数进行收发消息，这也印证了网络并没有多么高大上，socket也是一个文件描述符。

    3.客户端不需要手动bind，listen，accept，但是客户端需要自己connect服务器，connect会做两件事，bind和connect。

    4.客户端的端口号要操作系统随机分配，防止客户端出现启动冲突。想想如果多个应用程序都想占用一个端口号进行网络通信的场景。

    5.inet_aton函数

    #include

    #include

    #include

       

    int inet_aton(const char *cp, struct in_addr *inp);//cp必须是点分十进制字符串

    把“192.168.1.1”这样的点分十进制字符串转换成struct sockaddr_in结构体里面的in_addr结构体（网络序列）。已知in_addr结构体里面只有一个成员，一个32位无符号整数。

    成功返回0，失败返回非0；
     

     使用方法：

    6.使用signal(SIGCHLD, SIG_IGN)处理僵尸进程
    通过signal(SIGCHLD, SIG_IGN)通知内核对子进程的结束不关心，由内核回收。如果不想让父进程挂起，可以在父进程中加入一条语句：signal(SIGCHLD,SIG_IGN)。表示父进程忽略SIGCHLD信号，该信号是子进程退出的时候向父进程发送的。
     

    代码：

    tcp_server.cc

    1. #include "tcp_server.hpp"
    2. #include
    3. #include
    4. #include 
    5. using namespace ns_server;
    6.  
    7. static void Usage(string proc)
    8. {
    9.     cout << "Usage:\n\t" << proc << " port\n"<< endl;
    10. }
    11.  
    12. static string echo(string message)
    13. {
    14.     return message;
    15. }
    16.  
    17.  
    18. // .tcp_server serverport
    19. int main(int argc,char* argv[])
    20. {
    21.     if(argc!=2)
    22.     {
    23.         Usage(argv[0]);
    24.         exit(USAGE_ERR);
    25.     }
    26.     uint16_t serverport=atoi(argv[1]);
    27.  
    28.     unique_ptr tsvr(new TcpServer(serverport,echo));
    29.  
    30.     tsvr->InitServer();
    31.     tsvr->Start();
    32.  
    33.     return 0;
    34. }

    tcp_server.hpp

    1. #pragma once
    2. #include 
    3. using namespace std;
    4. #include 
    5. #include "err.hpp"
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include
    14. #include
    15. #include"ThreadPool.hpp"
    16. #include "Task.hpp"
    17. #include "Thread.hpp"
    18. #include "lockGuard.hpp"
    19. #include "log.hpp"
    20.  
    21. namespace ns_server
    22. {
    23.  
    24.     class TcpServer;
    25.     class ThreadData
    26.     {
    27.         public:
    28.             ThreadData(TcpServer* current,int sock,string client_ip,uint16_t client_port)
    29.             :_current(current),_sock(sock),_client_ip(client_ip),_client_port(client_port)
    30.             {
    31.  
    32.             }
    33.  
    34.             ~ThreadData(){}
    35.  
    36.             TcpServer* _current;
    37.             int _sock;
    38.             string _client_ip;
    39.             uint16_t _client_port;
    40.            
    41.     };
    42.  
    43.  
    44.     static const uint32_t backlog = 32;
    45.     static const uint16_t defaultport = 8888;
    46.     using func_t = function<string(const string&)>;
    47.  
    48.     class TcpServer
    49.     {
    50.  
    51.     public:
    52.         TcpServer(uint16_t port ,func_t func)
    53.             : _port(port), _func(func), _quit(true)
    54.         {}
    55.  
    56.         void InitServer()
    57.         {
    58.             // 1.创建监听套接字
    59.             _listensock = socket(AF_INET, SOCK_STREAM, 0);
    60.             if (_listensock < 0)
    61.             {
    62.                 //cerr << "Socket create error!" << endl;
    63.                 logMessage(Fatal, "create socket error, code: %d, error string: %s",errno,strerror(errno));
    64.                 exit(SOCKET_ERR);
    65.             }
    66.             logMessage(Info, "create socket success, code: %d, error string: %s", errno, strerror(errno));
    67.  
    68.  
    69.             // 2.绑定本地端口与IP
    70.             struct sockaddr_in local;
    71.             memset(&local, 0, sizeof(local));
    72.             local.sin_family = AF_INET;
    73.             local.sin_addr.s_addr = htons(INADDR_ANY); // 32位全零，不用转成网络序列，因为主机序列与网络序列一样；
    74.             local.sin_port = htons(_port);
    75.             int n1 = bind(_listensock, (const struct sockaddr *)&local, sizeof(local));
    76.             if (n1 < 0)
    77.             {
    78.                 //cerr << "Bind socket error!" << endl;
    79.                 logMessage(Fatal, "bind socket error, code: %d, error string: %s",errno,strerror(errno));
    80.                 exit(BIND_ERR);
    81.             }
    82.             logMessage(Info, "bind socket success, code: %d, error string: %s",errno,strerror(errno));
    83.  
    84.             // 3.监听
    85.             int n2 = listen(_listensock, backlog);
    86.             if (n2 < 0)
    87.             {
    88.                 //cerr << "Listen socket error!" << endl;
    89.                 logMessage(Fatal, "listen socket error, code: %d, error string: %s", errno, strerror(errno));
    90.                 exit(LISTEN_ERR);
    91.             }
    92.             logMessage(Info, "listen socket success, code: %d, error string: %s", errno, strerror(errno));
    93.         }
    94.  
    95.         void Start()
    96.         {
    97.             // signal(SIGCHLD,SIG_IGN);//不关心子进程的退出，由内核回收；
    98.  
    99.             _quit = false;
    100.  
    101.            
    102.           
    103.  
    104.             while (!_quit)
    105.             {
    106.                 
    107.                 struct sockaddr_in client;
    108.                 socklen_t len = sizeof(client);
    109.  
    110.                 // 4.不断获取新的客户端的连接，没有就阻塞；
    111.                 int sock = accept(_listensock, (struct sockaddr *)&client, &len);
    112.          
    113.                 if (sock < 0)
    114.                 {
    115.                     //cerr << "ACCEPT  error!" << endl;
    116.                     logMessage(Warning, "accept  error, code: %d, error string: %s", errno, strerror(errno));
    117.                     continue;
    118.                 } 
    119.              
    120.                 
    121.                 // 提取client信息---debug；
    122.                 string client_ip = inet_ntoa(client.sin_addr);//从网络序列转成主机序列，并将点分十进制字符串
    123.                 uint16_t client_port = ntohs(client.sin_port);// 网络序列转为主机序列
    124.                 //cout << client_ip << "-" << client_port<<"连接成功"<< endl; 
    125.                 logMessage(Info, "accept  success,%d from %d,name:%s-%d",sock,_listensock,client_ip.c_str(),client_port);
    126.  
    127.                 
    128.                 //线程池（主线程只负责接受客户端信息，并为其创建套接字进行沟通）
    129.                 //1.创建线程池
    130.                 //2.利用次线程处理沟通
    131.  
    132.                 //线程池一定是有限个线程个数，一定是处理短任务
    133.                 Task t(sock,client_ip,client_port,bind(&TcpServer::service,this,placeholders::_1,placeholders::_2,placeholders::_3));
    134.                 ThreadPool::getinstance()->pushtask(t);
    135.  
    136.  
    137.  
    138.                 // //多线程
    139.                 // pthread_t tid;
    140.                 // ThreadData* td=new ThreadData(this,sock,client_ip,client_port);
    141.                 // //因为threadRoutine函数只能有一个参数，想让线程执行service函数就必须把this指针，还有其它参数传过去，这时候可以利用一个结构体；
    142.                 // pthread_create(&tid,nullptr,threadRoutine,td);
    143.  
    144.  
    145.  
    146.  
    147.  
    148.             //    //多进程（父进程负责连接，子进程负责业务）
    149.             //     pid_t id=fork();
    150.             //     if(id<0)
    151.             //     {
    152.             //         //创建子进程失败；
    153.             //         close(sock);
    154.             //         cerr<
    155.             //         continue;
    156.             //     }
    157.             //     else if(id==0)
    158.             //     {
    159.             //         //子进程
    160.                     
    161.             //         close(_listensock);
    162.             //         // if(fork>0) exit(0);//创建一个孙子进程，儿子进程直接退出。利用孤儿进程处理业务，系统自动回收资源；
    163.                     
    164.                    
    165.             //         service(sock,client_ip,client_port);
    166.             //         exit(0);//子进程执行完服务直接退出；
    167.             //     }
    168.  
    169.             //     //父进程
    170.  
    171.             //     close(sock);//子进程已经继承到sock文件描述符，关闭父进程的sock;
    172.  
    173.             //     // //回收子进程
    174.             //     // int ret=waitpid(id,nullptr,0);//不获取退出码
    175.             //     // if(ret==id) cout<<"回收子进程"<
    176.                 
    177.             }
    178.         }
    179.         // static void *threadRoutine(void* args)
    180.         // {
    181.         //     //直接分离不用回收
    182.         //     pthread_detach(pthread_self());
    183.  
    184.         //     ThreadData* td=static_cast(args);
    185.  
    186.         //     td->_current->service(td->_sock,td->_client_ip,td->_client_port); 
    187.         //     delete td;
    188.         //     return nullptr;
    189.         // }
    190.  
    191.  
    192.         void service(int sock,string client_ip,uint16_t client_port)
    193.         {
    194.  
    195.             string name;
    196.             name+=client_ip;
    197.             name+="-";
    198.             name+=to_string(client_port);
    199.             char buffer[1024];
    200.             
    201.             while (true)//为某个客户端不间断服务
    202.             {
    203.                 int n = read(sock, buffer, sizeof(buffer) - 1);
    204.                 if (n > 0)
    205.                 {
    206.                     buffer[n]=0;
    207.                     string res=_func(buffer);
    208.  
    209.                     logMessage(Debug, "%s# %s", name.c_str(), res.c_str());
    210.                     write(sock,res.c_str(),res.size());
    211.                 }
    212.  
    213.                 else if (n == 0)
    214.                 {
    215.                     //说明对方断开连接了
    216.  
    217.                     close(sock);//关闭文件描述符
    218.                     logMessage(Info, "%s quit,me too",name.c_str());
    219.                     break;
    220.                 }
    221.                 else
    222.                 {
    223.                     //cout << "read error:" <
    224.                     logMessage(Error, "read error, %d:%s", errno, strerror(errno));
    225.                     break;
    226.                 }
    227.             }
    228.         }
    229.  
    230.         ~TcpServer()
    231.         {
    232.         }
    233.  
    234.     private:
    235.         uint16_t _port;
    236.         int _listensock;
    237.         bool _quit;
    238.         func_t _func;
    239.     };
    240.  
    241. }

    tcp_client.cc

    1.  
    2. #include 
    3. using namespace std;
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include
    10. #include
    11. //sockaddr_in结构体的头文件,当然也包含一些主机转网络序列的函数比如htons
    12. #include 
    13. #include 
    14.  
    15. #include "err.hpp"
    16.  
    17.  
    18.  
    19.  
    20. // static void* rfo(void *args)
    21. // {
    22. //     int sock=*(static_cast(args));
    23. //     while(true)
    24. //     {
    25. //           //收
    26. //         char buffer[4096];
    27. //         struct sockaddr_in tmp;//输入型参数；
    28. //         socklen_t len=sizeof(tmp);//要初始化，不然没法修改；
    29.         
    30. //         //阻塞式接收
    31. //         int n=recvfrom(sock,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&tmp,&len);
    32.       
    33. //         if(n>0)//接收服务器数据成功
    34. //         {
    35. //             buffer[n]=0;
    36. //             cout<
    37. //         }
    38. //     }
    39.  
    40.  
    41. // }
    42.  
    43. //当传入程序参数个数不对时，调用这个Usage函数告诉他什么是他妈的惊喜！
    44. static void Usage(string proc)
    45. {
    46.     cout<<"Usage:\n\t"<" serverip "<<" serverport\n"<
    47. }
    48.  
    49.  
    50.  
    51.  
    52.  
    53.  
    54.  
    55. // ./tcp_client serverip serverport
    56. int main(int argc,char* argv[])
    57. {
    58.     if(argc!=3)
    59.     {
    60.         Usage(argv[0]);
    61.         exit(USAGE_ERR);
    62.     }
    63.  
    64.     //保留输入的服务器的IP地址与端口号
    65.     string serverip=argv[1];
    66.     uint16_t serverport=atoi(argv[2]);
    67.  
    68.     //1.客户端创建套接字
    69.     int sock = socket(AF_INET, SOCK_STREAM, 0);
    70.     if (sock < 0)
    71.     {
    72.         cerr << " create socket error " << strerror(errno) << endl;
    73.         exit(SOCKET_ERR);
    74.     }
    75.     
    76.   
    77.  
    78.     //明确server是谁
    79.     struct sockaddr_in server;
    80.     memset((void*)&server,0,sizeof(server));
    81.     server.sin_family=AF_INET;
    82.     server.sin_port=htons(serverport);//主机序列转网络序列
    83.     
    84.     //把字符串转成sockaddr_in结构体里的结构体
    85.     inet_aton(serverip.c_str(),&(server.sin_addr));
    86.  
    87.     socklen_t len =sizeof(server);
    88.     
    89.   
    90.     int cnt=5;
    91.     cout<<"cnt=5"<
    92.     //2.连接服务器
    93.     while(connect(sock,(struct sockaddr*)&server,len)!=0)
    94.     {
    95.         cout<<"正在重新连接中,还有"<"次重新连接机会"<
    96.  
    97.         if(cnt--<=0) break;
    98.     }
    99.  
    100.     if(cnt<=0)
    101.     {
    102.         cout<<"连接失败"<
    103.         exit(CONNECT_ERR);
    104.     }
    105.  
    106.     else
    107.     {
    108.         cout<<"连接成功"<
    109.     }
    110.  
    111.     char buffer[1024];
    112.     while(true)
    113.     {
    114.         string message;
    115.         cout<<"Enter>>>";
    116.         getline(cin,message);
    117.         
    118.         write(sock,message.c_str(),message.size());//给服务器发数据
    119.         
    120.  
    121.         ssize_t n=read(sock,buffer,sizeof(buffer)-1);//如果服务器没有发送数据，这里会阻塞；
    122.         if(n>0)
    123.         {
    124.             buffer[n]=0;
    125.             cout<<"server echo>>>"<//打印服务器传输来的数据；
    126.         }
    127.         else if(n==0)
    128.         {
    129.             cout<<"与服务器断开了"<
    130.             break;
    131.         }
    132.         else
    133.         {
    134.             cout<<"read error"<<strerror(errno)<
    135.             break;
    136.         }
    137.  
    138.     }
    139.  
    140.     //关闭文件描述符（虽然进程退出自动关闭）
    141.     close(sock);
    142.  
    143.     return 0;
    144. }

    log.hpp

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include
    9. #include
    10. enum
    11. {
    12.     Debug = 0,
    13.     Info,
    14.     Warning,
    15.     Error,
    16.     Fatal,
    17.     Uknown
    18. };
    19.  
    20. static std::string toLevelString(int level)
    21. {
    22.     switch (level)
    23.     {
    24.     case Debug:
    25.         return "Debug";
    26.     case Info:
    27.         return "Info";
    28.     case Warning:
    29.         return "Warning";
    30.     case Error:
    31.         return "Error";
    32.     case Fatal:
    33.         return "Fatal";
    34.     default:
    35.         return "Uknown";
    36.     }
    37. }
    38.  
    39. static std::string gettime()
    40. {
    41.     time_t curr = time(nullptr);
    42.     struct tm *tmp = localtime(&curr);
    43.     char buffer[128];
    44.     snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
    45.              tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
    46.     return buffer;
    47. }
    48.  
    49. // 日志格式: 日志等级 时间 pid 消息体
    50.  
    51. void logMessage(int level, const char *format, ...) // format是%d、%s这样的形式，也就是printf("%d %s",a,b);
    52. {
    53.     char logLeft[1024];
    54.     std::string level_string = toLevelString(level);
    55.     std::string curr_time = gettime();
    56.     snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d]", level_string.c_str(), curr_time.c_str(), getpid());
    57.  
    58.     char logRight[1024];
    59.     // 可变参数
    60.     va_list p;           // 指向可变参数的开始处，
    61.     //va_arg(p, int);  // 根据类型提取参数,凭借%d这样的格式判定类型与大小。
    62.     va_start(p, format); // p=const char*& format
    63.  
    64.     vsnprintf(logRight, sizeof(logRight), format, p); // 向logRight缓冲区里面打印所有参数。
    65.  
    66.     va_end(p); // p=nullptr
    67.     printf("%s%s\n", logLeft, logRight);
    68.  
    69.     
    70. }

    ThreadPool.hpp

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. using namespace std;
    10.  
    11. #include "Task.hpp"
    12. #include "Thread.hpp"
    13. #include "lockGuard.hpp"
    14. #include "log.hpp"
    15. const int N = 6;
    16.  
    17. template <class T>
    18. class ThreadPool
    19. {
    20.  
    21. public:
    22.     //                                    单例模式
    23.     static ThreadPool *getinstance()
    24.     {
    25.         if (_instance == nullptr) // 当一个对象已经被创建以后，就不进入申请锁并且判断的环节了；
    26.         {
    27.             lockGuard lock(&_mutex_instance);
    28.             if (_instance == nullptr)
    29.             {
    30.                
    31.                 _instance = new ThreadPool();
    32.                  logMessage(Debug, "线程池单例形成");
    33.                 _instance->init();
    34.                 _instance->start();
    35.             }
    36.         }
    37.         return _instance;
    38.     }
    39.  
    40.     bool isEmpty()
    41.     {
    42.         return _tasks.empty();
    43.     }
    44.  
    45.     void init()
    46.     {
    47.         // 创建线程
    48.         for (int i = 1; i <= _num; ++i)
    49.         // pthread_create(&_threads[i],nullptr,ThreadRoutine,this);
    50.         {
    51.             _threads.push_back(Thread(i, ThreadRoutine, this));
    52.             logMessage(Debug, "%d thread running", i);
    53.         }
    54.     }
    55.  
    56.     void start()
    57.     {
    58.         // 线程启动
    59.         for (auto &e : _threads)
    60.         {
    61.             e.run();
    62.         }
    63.     }
    64.  
    65.     void check()
    66.     {
    67.         for (auto &e : _threads)
    68.         {
    69.             std::cout << "线程ID" << e.threadid() << " , " << e.threadname() << "is running··· " << std::endl;
    70.         }
    71.     }
    72.  
    73.     // 放入任务
    74.     void pushtask(const T &task)
    75.     {
    76.         lockGuard lock(&_mutex);
    77.         _tasks.push(task);
    78.  
    79.         threadwakeup(); // 有新任务进来，唤醒线程去处理
    80.     }
    81.  
    82.     // 拿出任务
    83.     T poptask()
    84.     {
    85.         T t = _tasks.front();
    86.         _tasks.pop();
    87.         return t;
    88.     }
    89.  
    90. private:
    91.     // 重点！！！
    92.     static void *ThreadRoutine(void *args)
    93.     {
    94.         pthread_detach(pthread_self());
    95.         // 指针强转成线程池对象类型；
    96.         ThreadPool *tp = static_cast *>(args);
    97.         while (true)
    98.         {
    99.  
    100.             T t;
    101.             {
    102.  
    103.                 lockGuard lock(tp->getlock());
    104.  
    105.                 // 1.判断是否有任务
    106.                 // 有->处理
    107.                 // 无->等待
    108.                 // 如果任务队列为空，则等待
    109.                 while (tp->isEmpty())
    110.                 {
    111.                     tp->threadwait();
    112.                 }
    113.                 t = tp->poptask(); // 从共有区域拿到线程独立栈上；
    114.             }
    115.  
    116.             t(); // 调用task类里面的仿函数处理任务
    117.         }
    118.     }
    119.  
    120. private:
    121.     ThreadPool(int num = N)
    122.         : _num(num)
    123.  
    124.     {
    125.         pthread_mutex_init(&_mutex, nullptr);
    126.         pthread_cond_init(&_cond, nullptr);
    127.     }
    128.  
    129.  
    130.     ThreadPool(const ThreadPool &tp) = delete;     // 删除默认拷贝构造
    131.     void operator=(const ThreadPool &tp) = delete; // 删除赋值函数
    132.  
    133.     pthread_mutex_t *getlock()
    134.     {
    135.         return &_mutex;
    136.     }
    137.  
    138.     void threadwait()
    139.     {
    140.         // 挂起一个线程
    141.         pthread_cond_wait(&_cond, &_mutex);
    142.     }
    143.  
    144.     void threadwakeup()
    145.     {
    146.         // 唤醒一个线程
    147.         pthread_cond_signal(&_cond);
    148.     }
    149.  
    150.     ~ThreadPool()
    151.     {
    152.         for (auto &e : _threads)
    153.         {
    154.             e.join();
    155.         }
    156.         pthread_mutex_destroy(&_mutex);
    157.         pthread_cond_destroy(&_cond);
    158.     }
    159.  
    160. private:
    161.     std::vector _threads;
    162.     int _num; // 线程池里有几个线程；
    163.  
    164.     std::queue _tasks; // 使用STL的自动扩容的特性
    165.  
    166.     pthread_mutex_t _mutex;
    167.     pthread_cond_t _cond;
    168.  
    169.     static ThreadPool *_instance;        // 懒汉方式实现单例模式
    170.     static pthread_mutex_t _mutex_instance; // 单例对象有自己的锁
    171. };
    172.  
    173. // 静态变量初始化
    174. template <class T>
    175. ThreadPool *ThreadPool::_instance = nullptr;
    176.  
    177. template <class T>
    178. pthread_mutex_t ThreadPool::_mutex_instance = PTHREAD_MUTEX_INITIALIZER;

    Thread.hpp

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. class Thread
    8. {
    9. public:
    10.     typedef void* ( *func_t) (void*);
    11.     typedef enum
    12.     {
    13.         NEW=0,
    14.         RUNNING,
    15.         EXITED
    16.     }ThreadStatus;
    17.  
    18. public:
    19.       //状态：new，running，exited
    20.         int status()
    21.         {
    22.             return _status;
    23.         }
    24.  
    25.         //线程名
    26.         std::string threadname()
    27.         {
    28.             return _name;
    29.         }
    30.  
    31.         //线程ID（共享库中的进程地址空间的虚拟地址）
    32.         pthread_t threadid()
    33.         {
    34.             if(_status==RUNNING)//线程已经被创建，线程id已经输入到成员变量_tid中；
    35.                 return _tid;
    36.             else 
    37.             {  
    38.                 return 0;
    39.             }
    40.         }
    41.  
    42. public:
    43.  
    44.         //构造函数；
    45.         Thread(int num,func_t func,void* args)
    46.         :_tid(0),
    47.         _status(NEW),
    48.         _func(func),
    49.         _args(args)
    50.  
    51.         {
    52.             char name[128];
    53.             snprintf(name,sizeof(name),"thread-%d",num);
    54.             _name=name;
    55.         }
    56.         
    57.         //析构函数
    58.         ~Thread(){}
    59.  
    60.       
    61.  
    62.         //静态成员函数不能访问类内所有成员，因为没有this指针；
    63.         static void* runHelper(void *args)
    64.         {
    65.             Thread* td=(Thread*)args;
    66.             (*td)();//调用仿函数执行线程的回调函数；
    67.             return nullptr; 
    68.         }
    69.  
    70.         void operator()()//仿函数
    71.         {
    72.             //如果函数指针不为空，则执行该函数指针指向的回调函数；
    73.             if(_func!=nullptr)  _func(_args);
    74.         }
    75.  
    76.         //创建线程
    77.         void run()
    78.         {
    79.             //因为runHelper函数必须只能有一个void*参数，所以runHelper函数在类内必须定义为static，这样才没有this指针；
    80.             int n=pthread_create(&_tid,nullptr,runHelper,this);
    81.             if(n!=0) return exit(1);//线程创建失败，那么直接退出进程；
    82.             _status=RUNNING;
    83.         }
    84.  
    85.         //等待线程结束
    86.         void join()
    87.         {
    88.             int n=pthread_join(_tid,nullptr);
    89.             if(n!=0) 
    90.             {
    91.                 std::cerr<<"main thread join thread "<<_name<<" error "<
    92.                 return;
    93.             }
    94.             _status=EXITED;//线程退出；
    95.         }
    96.        
    97. private:
    98.     pthread_t _tid;//线程ID（原生线程库中为该线程所创建的TCB起始虚拟地址）
    99.     std::string _name;//线程名
    100.     func_t _func;//线程要执行的回调
    101.     void* _args;//线程回调函数参数
    102.     ThreadStatus _status;//枚举类型：状态
    103. };
    104.

    lockGuard.hpp

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5.  
    6. class Mutex//成员：加锁函数和解锁函数
    7. {
    8. public:
    9.     Mutex(pthread_mutex_t* pmutex):_pmutex(pmutex)   {}
    10.     
    11.     void lock()
    12.     {
    13.         pthread_mutex_lock(_pmutex);
    14.     }
    15.    
    16.        void unlock()
    17.     {
    18.         pthread_mutex_unlock(_pmutex);
    19.     }
    20.    
    21.  
    22.     ~Mutex(){}
    23.  
    24. private:
    25.     pthread_mutex_t* _pmutex;//需要传入一个互斥量（锁）的指针；
    26. };
    27.  
    28.  
    29. //对Mutex进行二次封装；
    30. //创建该对象时自动加锁，析构时自动解锁；
    31. class lockGuard
    32. {   
    33. public:
    34.     lockGuard(pthread_mutex_t* pmutex):_mutex(pmutex)//利用锁的指针构建Mutex对象
    35.     {
    36.         _mutex.lock();
    37.     }
    38.  
    39.    ~lockGuard()
    40.     {
    41.         _mutex.unlock();
    42.     }
    43.  
    44. private:
    45.     Mutex _mutex;//类内创建对象
    46. };

    Task.hpp

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. using namespace std;
    6.     using cb_t=function<void(int,string,uint16_t)>;
    7.  
    8.  
    9. class Task
    10. {
    11. public:
    12.     Task(){}
    13.     
    14.     Task(int sock,string clientip,uint16_t clientport,cb_t func)
    15.     :_sock(sock),
    16.     _clientip(clientip),
    17.     _clientport(clientport),
    18.     _func(func)
    19.     {}
    20.     
    21.     int operator()()
    22.     {
    23.         //开始为客户端---处理任务
    24.         cout<<"开始为客户端"<<_clientip<<"-"<<_clientport<<"服务"<
    25.        _func(_sock,_clientip,_clientport);//实际上是一个已经绑了一个参数的TcpServer::service函数；
    26.     }
    27.  
    28.  
    29.     ~Task() {}
    30.  
    31. private:
    32.     int _sock;
    33.     string _clientip;
    34.     uint16_t _clientport;
    35.     cb_t _func;
    36. };

    err.hpp

    1. #pragma once
    2.        enum
    3.         {   
    4.             USAGE_ERR=1,
    5.             SOCKET_ERR,
    6.             BIND_ERR,
    7.             LISTEN_ERR,
    8.             CONNECT_ERR,
    9.             SETSID_ERR
    10.         };

  • 相关阅读:
    C/C++ 单元自动化测试解决方案实践
    Linux-编译器
    java-php-python-ssm网上零食进销存计算机毕业设计
    二维码怎么做调查问卷？二维码统计数据的技巧
    历次工业革命的本质，都是能源转换的革命。（电学史的伟大瞬间）【电的本质】
    arudino 知识整理
    【gcc】RtpTransportControllerSend学习笔记 1
    阿里云物联网IOT平台使用案例教程(模拟智能设备)
    Qt之xml文件解析
    Vue3学习——标签的ref属性
  • 原文地址：https://blog.csdn.net/zzxz8/article/details/132855673