tcp_fork

#include  #include  #include  #include  #include           /* See NOTES */ #include  #include  #include  #include  #include  #include  #include   // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA);  // 信号处理函数，用于处理子进程结束的信号 void handle(int num) {     // 等待子进程结束，防止产生僵尸进程     wait(NULL); }  int main(int argc, char *argv[]) {     // 注册信号处理函数，当收到 SIGCHLD 信号时，调用 handle 函数     signal(SIGCHLD, handle);      // 创建监听套接字     int listfd = socket(AF_INET, SOCK_STREAM, 0);     if (-1 == listfd)     {         // 如果创建失败，打印错误信息并退出程序         perror("socket");         exit(1);     }      // 定义服务器地址结构体和客户端地址结构体，并初始化为 0     struct sockaddr_in ser, cli;     bzero(&ser, sizeof(ser));     bzero(&cli, sizeof(cli));      // 设置服务器地址结构体的参数     ser.sin_family = AF_INET; // 设置地址族为 IPv4     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址      // 设置套接字选项，允许地址和端口重用     int on = 1;     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));      // 将监听套接字与服务器地址绑定     int ret = bind(listfd, (SA)&ser, sizeof(ser));     if (-1 == ret)     {         // 如果绑定失败，打印错误信息并退出程序         perror("bind");         exit(1);     }      // 开始监听连接请求，设置排队连接数为 3     listen(listfd, 3);      // 客户端地址结构体的长度     socklen_t len = sizeof(cli);      while (1)     {         // 接受客户端连接请求，返回通讯套接字         int conn = accept(listfd, (SA)&cli, &len);         if (-1 == conn)         {             // 如果接受连接失败，打印错误信息并继续循环             perror("accept");             // exit(1);             continue;         }          // 创建子进程         pid_t pid = fork();         if (0 == pid)         {             // 子进程执行的代码             while (1)             {                 // 关闭监听套接字，因为子进程不需要它                 close(listfd);                 char buf[512] = {0};                 // 从通讯套接字接收数据                 int rd_ret = recv(conn, buf, sizeof(buf), 0);                 if (rd_ret <= 0)                 {                     // 如果接收数据失败或客户端断开连接，打印提示信息并关闭通讯套接字，退出子进程                     printf("cli off line\n");                     close(conn);                     // break;                     exit(1);                 }                 // 打印接收到的客户端数据                 printf("cli:%s\n", buf);                 time_t tm;                 // 获取当前时间                 time(&tm);                 // 将客户端数据和时间格式化后存入 buf 中                 sprintf(buf, "%s %s", buf, ctime(&tm));                 // 将 buf 中的数据发送回客户端                 send(conn, buf, strlen(buf), 0);             }         }         else if (pid > 0)         {             // 父进程执行的代码，关闭通讯套接字             close(conn);         }         else         {             // 如果 fork 失败，打印提示信息并继续循环             printf("fork");             continue;         }     }     // 关闭监听套接字     close(listfd);     return 0; }

这段代码实现了一个简单的 TCP 服务器，它在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个子进程来处理与该客户端的通信。子进程会接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。同时，服务器还注册了一个信号处理函数来处理子进程结束的信号，以防止产生僵尸进程。 

tcp_pthread 

#include  #include  #include  #include  #include           /* See NOTES */ #include  #include  #include  #include  #include  #include  #include  #include   // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA);  // 线程函数，用于处理与客户端的通信 void* th(void* arg) {     // 将当前线程设置为分离状态，无需主线程进行连接     pthread_detach(pthread_self());     int conn =* (int*)arg;     //sem_post();     while (1)     {         char buf[512] = {0};         // 从通讯套接字接收数据         int rd_ret = recv(conn, buf, sizeof(buf), 0);         if (rd_ret <= 0)         {             // 如果接收数据失败或客户端断开连接，打印提示信息并关闭通讯套接字，退出线程             printf("cli off line\n");             close(conn);             break;         }         // 打印接收到的客户端数据         printf("cli:%s\n", buf);         time_t tm;         // 获取当前时间         time(&tm);         // 将客户端数据和时间格式化后存入 buf 中         sprintf(buf, "%s %s", buf, ctime(&tm));         // 将 buf 中的数据发送回客户端         send(conn, buf, strlen(buf), 0);     }      return NULL; }  int main(int argc, char *argv[]) {     // 创建监听套接字     int listfd = socket(AF_INET, SOCK_STREAM, 0);     if (-1 == listfd)     {         // 如果创建失败，打印错误信息并退出程序         perror("socket");         exit(1);     }      // 定义服务器地址结构体和客户端地址结构体，并初始化为 0     struct sockaddr_in ser, cli;     bzero(&ser, sizeof(ser));     bzero(&cli, sizeof(cli));      // 设置服务器地址结构体的参数     ser.sin_family = AF_INET; // 设置地址族为 IPv4     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址      // 设置套接字选项，允许地址和端口重用     int on = 1;     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));      // 将监听套接字与服务器地址绑定     int ret = bind(listfd, (SA)&ser, sizeof(ser));     if (-1 == ret)     {         // 如果绑定失败，打印错误信息并退出程序         perror("bind");         exit(1);     }      // 开始监听连接请求，设置排队连接数为 3     listen(listfd, 3);      // 客户端地址结构体的长度     socklen_t len = sizeof(cli);      while (1)     {         // 接受客户端连接请求，返回通讯套接字         int conn = accept(listfd, (SA)&cli, &len);         if (-1 == conn)         {             // 如果接受连接失败，打印错误信息并继续循环             perror("accept");             // exit(1);             continue;         }          pthread_t tid;         // 创建一个新线程来处理与客户端的通信         pthread_create(&tid, NULL, th, &conn);         //sem_wait();         // join();         // 确保 th 中，把 conn 保存到局部变量中         usleep(1000 * 5);     }     // 关闭监听套接字     close(listfd);     return 0; }

这段代码实现了一个多线程的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个新线程来处理与该客户端的通信。每个线程独立地与对应的客户端进行交互，接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。

主要步骤如下：

1. 创建监听套接字，并设置服务器地址和端口等参数。
2. 允许地址和端口重用。
3. 绑定监听套接字到服务器地址。
4. 开始监听连接请求。
5. 在循环中，接受客户端连接请求。
6. 为每个连接创建一个新线程，传入连接套接字的指针作为参数。
7. 新线程在分离状态下运行，处理与客户端的通信。
8. 主线程继续接受新的连接请求。

tcp_select

#include  #include  #include  #include  #include           /* See NOTES */ #include  #include  #include  #include  #include  /* According to POSIX.1-2001, POSIX.1-2008 */ #include   /* According to earlier standards */ #include  #include  #include   // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA);  int main(int argc, char *argv[]) {     // 创建监听套接字     int listfd = socket(AF_INET, SOCK_STREAM, 0);     if (-1 == listfd)     {         // 如果创建失败，打印错误信息并退出程序         perror("socket");         exit(1);     }      // 定义服务器地址结构体和客户端地址结构体，并初始化为 0     struct sockaddr_in ser, cli;     bzero(&ser, sizeof(ser));     bzero(&cli, sizeof(cli));      // 设置服务器地址结构体的参数     ser.sin_family = AF_INET; // 设置地址族为 IPv4     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址      // 设置套接字选项，允许地址和端口重用     int on = 1;     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));      // 将监听套接字与服务器地址绑定     int ret = bind(listfd, (SA)&ser, sizeof(ser));     if (-1 == ret)     {         // 如果绑定失败，打印错误信息并退出程序         perror("bind");         exit(1);     }      // 开始监听连接请求，设置排队连接数为 3     listen(listfd, 3);      // 客户端地址结构体的长度     socklen_t len = sizeof(cli);      // 1. 创建文件描述符集合     fd_set rd_set, tmp_set;     FD_ZERO(&rd_set); // 清空读集合     FD_ZERO(&tmp_set); // 清空临时集合      // 2. 将监听套接字添加到临时集合     FD_SET(listfd, &tmp_set);      // 记录当前最大的文件描述符     int maxfd = listfd;      while (1)     {         // 复制临时集合到读集合，用于 select 调用         rd_set = tmp_set;          // 使用 select 函数监控文件描述符集合中的读事件         select(maxfd + 1, &rd_set, NULL, NULL, NULL);          int i = 0;         // 遍历所有可能的文件描述符         for (i = 0; i < maxfd + 1; i++)         {             // 如果当前文件描述符在读集合中被置位，并且是监听套接字             if (FD_ISSET(i, &rd_set) && i == listfd)             {                 // 接受客户端连接请求，返回通讯套接字                 int conn = accept(listfd, (SA)&cli, &len);                 if (-1 == conn)                 {                     // 如果接受连接失败，打印错误信息并继续循环                     perror("accept");                     // exit(1);                     continue;                 }                  // 将新的连接套接字添加到临时集合                 FD_SET(conn, &tmp_set);                  // 更新最大文件描述符                 if (conn > maxfd)                     maxfd = conn;             }             // 如果当前文件描述符在读集合中被置位，并且不是监听套接字             if (FD_ISSET(i, &rd_set) && i!= listfd)             {                 int conn = i;                 char buf[512] = {0};                 // 从通讯套接字接收数据                 int rd_ret = recv(conn, buf, sizeof(buf), 0);                 if (rd_ret <= 0)                 {                     // 如果接收数据失败或客户端断开连接，从临时集合中清除该套接字，并关闭连接                     FD_CLR(conn, &tmp_set);                     close(conn);                     printf("cli offline\n");                     break;                 }                 // 打印接收到的客户端数据（注释掉了）                 //printf("cli:%s\n", buf);                 time_t tm;                 // 获取当前时间                 time(&tm);                 // 将客户端数据和时间格式化后存入 buf 中                 sprintf(buf, "%s %s", buf, ctime(&tm));                 // 将 buf 中的数据发送回客户端                 send(conn, buf, strlen(buf), 0);             }         }     }     // 关闭监听套接字     close(listfd);     return 0; }

这段代码实现了一个基于select函数的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。

主要步骤如下：

1. 创建监听套接字，并设置服务器地址和端口等参数。
2. 允许地址和端口重用。
3. 绑定监听套接字到服务器地址。
4. 开始监听连接请求。
5. 创建文件描述符集合，将监听套接字添加到集合中，并记录最大文件描述符。
6. 在循环中，使用select函数监控文件描述符集合中的读事件。
7. 如果监听套接字有可读事件，接受客户端连接请求，并将新的连接套接字添加到集合中，更新最大文件描述符。
8. 如果其他套接字有可读事件，接收数据，处理数据（加上时间戳后发送回客户端），如果连接断开，从集合中清除该套接字并关闭连接。

tcp_epoll

#include  #include  #include  #include  #include           /* See NOTES */ #include  #include  #include  #include  #include  #include   // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA);  // 向 epoll 实例添加文件描述符的函数 int add_fd(int epfd, int fd) {     struct epoll_event ev;     ev.events = EPOLLIN; // 关注读事件     ev.data.fd = fd;     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);     if (-1 == ret)     {         perror("add fd");     }     return ret; }  // 从 epoll 实例删除文件描述符的函数 int del_fd(int epfd, int fd) {     struct epoll_event ev;     ev.events = EPOLLIN;     ev.data.fd = fd;     int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);     if (-1 == ret)     {         perror("add fd");     }     return ret; }  int main(int argc, char *argv[]) {     // 创建监听套接字     int listfd = socket(AF_INET, SOCK_STREAM, 0);     if (-1 == listfd)     {         // 如果创建失败，打印错误信息并退出程序         perror("socket");         exit(1);     }      // 定义服务器地址结构体和客户端地址结构体，并初始化为 0     struct sockaddr_in ser, cli;     bzero(&ser, sizeof(ser));     bzero(&cli, sizeof(cli));      // 设置服务器地址结构体的参数     ser.sin_family = AF_INET; // 设置地址族为 IPv4     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址      // 设置套接字选项，允许地址和端口重用     int on = 1;     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));      // 将监听套接字与服务器地址绑定     int ret = bind(listfd, (SA)&ser, sizeof(ser));     if (-1 == ret)     {         // 如果绑定失败，打印错误信息并退出程序         perror("bind");         exit(1);     }      // 开始监听连接请求，设置排队连接数为 3     listen(listfd, 3);      // 客户端地址结构体的长度     socklen_t len = sizeof(cli);      struct epoll_event rev[10] = {0};     // 1. 创建 epoll 实例     int epfd = epoll_create(10);     if (-1 == epfd)     {         // 如果创建失败，打印错误信息并返回         perror("epoll_create");         return 1;     }     // 2. 将监听套接字添加到 epoll 实例     add_fd(epfd, listfd);      while (1)     {         // 3. 等待事件发生         int ep_ret = epoll_wait(epfd, rev, 10, -1);         int i = 0;         // 4. 查找有事件的文件描述符并处理         for (i = 0; i < ep_ret; i++)         {             if (rev[i].data.fd == listfd)             {                 // 如果是监听套接字有事件，表示有新的连接请求                 int conn = accept(listfd, (SA)&cli, &len);                 if (-1 == conn)                 {                     // 如果接受连接失败，打印错误信息并继续循环                     perror("accept");                     continue;                 }                 // 将新的连接套接字添加到 epoll 实例                 add_fd(epfd, conn);             }             else             {                 int conn = rev[i].data.fd;                 char buf[512] = {0};                 // 从连接套接字接收数据                 int rd_ret = recv(conn, buf, sizeof(buf), 0);                 if (rd_ret <= 0)                 {                     // 如果接收数据失败或客户端断开连接，从 epoll 实例中删除该套接字，并关闭连接                     del_fd(epfd, conn);                     close(conn);                     break;                 }                 time_t tm;                 // 获取当前时间                 time(&tm);                 // 将客户端数据和时间格式化后存入 buf 中                 sprintf(buf, "%s %s", buf, ctime(&tm));                 // 将 buf 中的数据发送回客户端                 send(conn, buf, strlen(buf), 0);             }         }     }     // 关闭监听套接字     close(listfd);     return 0; }

这段代码实现了一个基于epoll的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。

主要步骤如下：

1. 创建监听套接字，并设置服务器地址和端口等参数。
2. 允许地址和端口重用。
3. 绑定监听套接字到服务器地址。
4. 开始监听连接请求。
5. 创建epoll实例。
6. 将监听套接字添加到epoll实例中。
7. 在循环中，使用epoll_wait等待事件发生。
8. 当有事件发生时，检查是监听套接字还是连接套接字的事件。如果是监听套接字的事件，接受新的连接请求，并将新的连接套接字添加到epoll实例中。如果是连接套接字的事件，接收数据，处理数据（加上时间戳后发送回客户端），如果连接断开，从epoll实例中删除该套接字并关闭连接。

服务端 

#include  #include  #include  #include  #include           /* See NOTES */ #include  #include  #include  #include  #include  #include   // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA);  int main(int argc, char *argv[]) {     // 创建客户端套接字     int conn = socket(AF_INET, SOCK_STREAM, 0);     if (-1 == conn)     {         // 如果创建失败，打印错误信息并退出程序         perror("socket");         exit(1);     }      // 定义服务器地址结构体，并初始化为 0     struct sockaddr_in ser;     bzero(&ser, sizeof(ser));     // 设置地址族为 IPv4     ser.sin_family = AF_INET;     // 设置端口号为 50000，并转换为网络字节序     ser.sin_port = htons(50000);     // 设置服务器 IP 地址为本地回环地址     ser.sin_addr.s_addr = inet_addr("127.0.0.1");      // 连接到服务器     int ret = connect(conn, (SA)&ser, sizeof(ser));     if (-1 == ret)     {         // 如果连接失败，打印错误信息并退出程序         perror("connect");         exit(1);     }      int i = 5;     // 设置超时时间结构体     struct timeval tv;     tv.tv_sec = 3;  // 秒数为 3     tv.tv_usec = 0; // 微秒数为 0     // 设置套接字接收超时时间     setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));       while (1)     {         // 发送数据给服务器         char buf[512]="hello,this tcp test";         send(conn, buf, strlen(buf), 0);         bzero(buf, sizeof(buf));         // 从服务器接收数据         int ret = recv(conn, buf, sizeof(buf), 0);         if (ret == 0)         {             // 如果接收返回 0，表示服务器关闭连接             printf("ser close\n");             break;         }         if (ret <= 0)         {             // 如果接收返回小于等于 0，表示接收失败或超时             printf("time out,contineu\n");         }         // 打印接收到的服务器数据         printf("ser:%s\n", buf);         // 睡眠 1 秒         sleep(1);     }     // 关闭客户端套接字     close(conn);     return 0; }

这段代码实现了一个简单的 TCP 客户端。它连接到本地回环地址的 50000 端口上的服务器，发送数据并接收服务器的响应。同时，设置了接收超时时间为 3 秒，如果在 3 秒内没有接收到数据，就会打印超时信息并继续循环。客户端会不断发送数据、接收响应并打印，直到服务器关闭连接。