TCP 通信程序示例——实现一个服务器连接多个客户端

已于 2024-09-03 21:18:24 修改
阅读量375 收藏 3
点赞数 16
文章标签： linux 学习 c语言 网络协议
于 2024-09-03 21:17:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63556308/article/details/141871907
版权

 tcp_fork

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <signal.h>
#include <sys/wait.h>

// 定义一个类型别名，方便后续使用
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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <signal.h>
#include <sys/wait.h>
#include <pthread.h>

// 定义一个类型别名，方便后续使用
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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
/* According to POSIX.1-2001, POSIX.1-2008 */
#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

// 定义一个类型别名，方便后续使用
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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <sys/epoll.h>

// 定义一个类型别名，方便后续使用
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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <sys/time.h>

// 定义一个类型别名，方便后续使用
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 秒内没有接收到数据，就会打印超时信息并继续循环。客户端会不断发送数据、接收响应并打印，直到服务器关闭连接。

求学者1.0
关注
  • 16
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux下TCP/IP网络编程示例——实现服务器/客户端通信（一）
Mr_XJC的博客
06-16 1万+
一、说明 最近梳理网络编程的一些知识点时，整理了一些笔记，写了一些demo例程，主要包含下面几部分，后面会陆续完成。 1、Linux下TCP/IP网络编程示例——实现服务器/客户端通信（一）：基于socket实现基本的服务器与客户端通信，不支持多并发，即只支持与一个客户端通信。 2、Linux下TCP/IP网络编程示例——实现服务器/客户端通信（二）：基于socket实现基本的服务器与客户端通信，不使用多进程/多线程和多路复用，实现服务端多并发功能。 3、Linux下TCP/IP网络编程示例——实现服务
用TCP实现客户端与服务器通信-多线程Java
weixin_58480821的博客
03-20 516
使用Java进行网络编程，多线程使用 TCP实现服务器客户端之间通信，并且服务器会给客户端返回一个响应
网络编程3——TCP Socket实现的客户端服务器通信完整代码(详细注释帮你快速理解)
The_emperoor_man的博客
07-07 3888
教会你如何使用TCP Socket实现客户端与服务器的通信。详细介绍了相关类的属性与方法的作用，每行代码都有注释帮你分析它的作用，章尾解答客户端服务器的常见疑惑。
Windows下TCP编程——服务器客户端代码以及爬虫示例
AAAA202012的博客
10-20 2037
为什么Ieee浏览器能显示网站的照片等数据呢，是因为浏览器(客户端)给这个网站（服务器）发了一个请求，请求他的数据给我，这个网站服务器就将它的数据就发到我的这个Ieee上来，当然也能发到我写的程序。个人电脑上打了一个网址(www.xxxxxx),IE会生成一段码流(http协议的格式)，服务器将请求的结果(网页源代码)返回给IE，IE拿了源代码之后，根据其中的链接，再去各服务器获取图片内容。而我们的爬虫就是模拟IEEE生成一段码流，发送给服务器我们的请求，服务器将请求的结果返回。
Linux下TCP/IP网络编程示例——实现服务器/客户端通信（二）
Mr_XJC的博客
06-16 776
在《Linux下TCP/IP网络编程示例——实现服务器/客户端通信（一）》中，实现了基本的服务器/客户端通信，但是不支持多并发，下面在（一）的基础上实现服务器支持多并发，可以多个客户端同时连接并通信。 在上一篇中，说到socket()创建的套接字默认是阻塞的，所以accept()会一直阻塞等待客户端的连接请求；同时read也会阻塞等待读取数据。下面的例程中，会将套接字设为非阻塞模式，这样accept()和read()就不会阻塞等待，而是会在没有客户端连接请求以及没有数据可读时立即返回，并设置响应的错误码。
Linux下TCP/IP网络编程示例——实现服务器/客户端通信（三）
Mr_XJC的博客
06-17 913
Linux下TCP/IP网络编程示例——实现服务器/客户端通信（三）：基于socket实现基本的服务器与客户端通信，使用多线程实现服务端的多并发功能。 例程中使用多线程来实现多并发，每新来一个客户端连接请求，就新开一个线程去与该客户端进行通信。当对应客户端退出时，服务器结束对应的线程，为了及时回收结束线程的资源，在每次创建线程前，都先设置线程的分离属性，使得线程结束后，由系统自动回收线程资源。 server.c #include <stdio.h> #include <string
网络编程day2——基本TCP服务器与客户端搭建流程
weixin_54481049的博客
05-02 1171
函数的作用：它是创建网络通信端点（套接字）的第一步，为服务器在网络上提供服务打下基础。这个过程需要明确通信的细节，如服务范围、服务种类和具体协议，以确保后续通信的顺利进行。//相当于选择好邮局具体的地址，与开设具体的服务窗口。（这个和邮局点不一样，这里相当于邮局会对顾客的邮件进行处理，也许是读取，也许是完成你的需求，相当于升级的更加多功能的邮局吧）//相当于明确邮局提供的服务种类，是要慢一点但是有追踪保障的（UDP），还是火速但是有丢失风险的（TCP）。结构的指针，该结构包含了套接字需要绑定的地址信息。
TCP——如何用类封装 socket 实现客户端和服务端通信（代码逐行详解）
qq_41885018的博客
05-28 1221
private:// 客户端的socket，-1表示未连接或连接已断开；>=0表示有效的socket。// 服务端的IP/域名。// 通讯端口。public:private：放置了三个成员变量public：放了成员函数，析构函数、构造函数ctcpclient连接到服务器：通过connect方法连接到指定 IP 和端口的服务器。发送数据：通过send方法发送数据到服务器。接收数据：通过recv方法从服务器接收数据。关闭连接：通过close方法断开连接。
QT-TCP服务端开启多个线程处理收到多客户端发来的消息示例
ligare的博客
02-17 9179
一些用到的函数等解释: void incomingConnection ( int socketDescriptor ) 当有新连接可用时，QTcpServer将调用此虚拟函数。注意：如果希望将传入连接作为另一个线程中的新QTcpSocket对象处理，则必须将socketDescriptor传递给另一个线程，在那里创建QTcpSocket对象并使用其setSocketDescriptor()方法。 ...
Java网络编程入门（六）之TCP编程——使服务器端支持多个客户端同时工作
良月柒
10-29 1849
如何使服务器端支持多个客户端同时工作？          前面介绍的服务器端程序，只是实现了概念上的服务器端，离实际的服务器端程序结构距离还很遥远，如果需要让服务器端能够实际使用，那么最需要解决的问题就是——如何支持多个客户端同时工作。          一个服务器端一般都需要同时为多个客户端提供通讯，如果需要同时支持多个客户端，则必须使用前面介绍的线程的概念。简单来说，也就是当服务器端接收到...
Java网络编程之TCP协议下—上传文件到服务器程序
03-09
本教程将重点讲解如何利用Java实现一个简单的TCP文件上传到服务器的程序。 首先，我们来看`uploadServer.java`。这个文件代表服务器端的程序，主要任务是监听客户端的连接请求，并接收客户端发送过来的文件。在Java...
快速上手linux网络编程tcp服务器（csdn）————程序.pdf
12-05
4. **等待客户端连接**：类似于等待家人一起吃饭，`accept()`函数用于接收客户端的连接请求，返回一个新的套接字描述符用于与客户端通信。 5. **信息交换**：吃饭的过程，即数据的收发。使用`read()`和`write()`...
Linux高性能服务器编程 总结索引 | 第2章：IP协议详解
AsherGu的博客
08-29 1205
IP服务的特点；IPv4头部结构；IP分片；IP路由：IP模块工作流程，路由机制，路由表更新；IP转发；重定向；IPv6头部结构：IPv6固定头部结构，IPv6扩展头部
Linux 常用命令 - lsblk 【查看磁盘（块设备）使用情况】
随便转转
08-27 1292
lsblk源自于 “list block devices” 的缩写。这个命令用于列出系统中的所有块设备（block devices），比如硬盘、光驱等。它展示块设备的层次结构、大小和挂载点等信息，非常有助于系统管理员理解系统存储结构。
【Linux】Linux Bash Shell 教程
Young_Pro的博客
08-27 1591
Linux bash（Bourne-Again SHell）是一种为GNU操作系统编写的命令行解释器，它是大多数Linux发行版中最常用的shell。Bash提供了一种强大的方式来控制和管理操作系统，支持命令历史记录、别名、管道、重定向、变量、条件判断、循环以及自定义脚本编写等功能，使得用户能够通过简单的命令行指令执行复杂的任务，是系统管理员和开发人员日常工作中的得力工具。
在linux 中如何将.c 文件转换为可执行文件
千千道的博客
08-29 1694
在 Linux 环境下进行 C 语言编程时，将.c文件转换为可执行文件是一个关键的步骤。这个过程涉及到使用编译器和一些相关的工具，本文将详细介绍在 Linux 系统中如何将.c文件转换为可执行文件的方法。
在Linux中杀死占用某个端口的进程
靖妖傩舞
08-28 683
选项表示强制终止进程，但这种方式可能会导致数据丢失或其他不良后果，所以在使用时要谨慎。确定要杀死的进程 PID。从上述步骤中获取到占用端口 9997 的进程 PID。
Linux 命令行快捷键
sun007700的专栏
08-30 555
涉及在linux命令行下进行快速移动光标、命令编辑、编辑后执行历史命令、Bang(!Ctrl+y: 粘贴Ctrl+u或ctrl+k剪切的内容。Alt – d ：由光标位置开始，往右删除单词。Alt – d: 先按住 Alt 键，然后再按 d 键；Ctrl+u：删除当前光标前面的文字 (还有剪切功能)Ctrl+k：删除当前光标后面的文字 (还有剪切功能)M – k：先单击 Esc 键，然后再按 k 键。Ctrl+w: 删除光标前面的单词。Ctrl+左右键:在单词之间跳转。Ctrl+a: 跳到本行的行首。
linux查找mysql日志
最新发布
爱思考的People
08-30 503
MySQL的日志文件通常存储在数据库服务器的数据目录下，具体位置取决于MySQL的配置文件。# 查找MySQL配置文件# 查找MySQL日志文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值