【Linux网络】各版本TCP服务器构建 - 从理解到实现

已于 2025-04-22 23:35:02 修改
阅读量1.3k 收藏 41
点赞数 67
文章标签： 网络 服务器 linux
于 2025-04-22 23:20:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77954967/article/details/147403119
版权

📢博客主页：https://blog.csdn.net/2301_779549673
📢博客仓库：https://gitee.com/JohnKingW/linux_test/tree/master/lesson
📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
📢本文由 JohnKi 原创，首发于 CSDN🙉
📢未来很长，值得我们全力奔赴更美好的生活✨

在这里插入图片描述

在这里插入图片描述

文章目录

前面几篇文章中使用UDP协议实现了相关功能 ，这篇使用TCP协议实现客户端与服务端的通信

相比与UDP协议，TCP协议更加可靠，也更加复杂！与UDP类似，我们先写主函数，然后实现相关函数！

🏳️‍🌈一、TcpServer.cpp

服务端主函数使用智能指针构造Server对象，然后调用初始化与执行函数，调用主函数使用该可执行程序 + 端口号！

#include "TcpServer.hpp"


int main(int argc, char* argv[]){
    if(argc != 2){
        std::cerr << "Usage: " << argv[0] << " port" << std::endl;
        Die(1);
    }
    uint16_t port = std::stoi(argv[1]);

    std::unique_ptr<TcpServer> tsvr = std::make_unique<TcpServer>(port);

    tsvr->InitServer();
    tsvr->Loop();

    return 0;
}

🏳️‍🌈二、TcpServer.hpp

2.1 枚举错误情况

与 UDP 同样的，我们先枚举错误情况，将其放在 common.hpp 中

enum {
    USAGE_ERR = 1,
    SOCKET_ERR,
    BIND_ERR,
    LISTEN_ERR
};

2.2 基本结构

我们这里先实现最基本的 TCP 服务器，基本成员有端口号，文件描述符，与运行状态

class TcpServer{
    public:
        TcpServer(){}
        void InitServer(){}
        void Loop(int sockfd){}
        ~TcpServer(){}

    private:
        int _listensockfd; // 监听socket
        uint16_t _port;
        bool _isrunning;
};

2.3 构造函数、析构函数

构造函数初始化成员变量，析构函数无需处理！

  • 这里需要为端口号设置一个默认值 - 8080
static const uint16_t gport = 8080;
// 构造函数
TcpServer(uint16_t port = gport)
    :_port(port),_sockfd(gsockfd),_isrunning(false){}
// 析构函数
~TcpServer(){}

2.4 初始化方法

初始化函数主要分为三步：

  1. 创建 socket (类型与UDP不同)
  2. bind sockfd 和 socket addr
  3. 获取连接(与UDP不同)

获取连接需要使用 listen 函数(将套接字设置为监听模式，以便能够接受进入的连接请求)

·listen· 需要设置一个队列，用来保存等待连接地客户端，我们可以事先设置一个 #define BACKLOG 8 来定义这个队列长度

void InitServer() {
    // 1. 创建 socket
    _listensockfd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (_listensockfd < 0) {
        LOG(LogLevel::ERROR) << "create socket error: " << strerror(errno);
        Die(2);
    }
    LOG(LogLevel::INFO) << "create sockfd success: " << _listensockfd;

    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = htonl(INADDR_ANY);

    // 2. 绑定 socket
    if (::bind(_listensockfd, CONV(&local), sizeof(local)) < 0) {
        LOG(LogLevel::ERROR) << "bind socket error: " << strerror(errno);
        Die(3);
    }
    LOG(LogLevel::INFO) << "bind sockfd success: " << _listensockfd;

    // 3. 因为 tcp 是面向连接的，tcp需要未来不断地获取连接
    // listen 就是监听连接的意思，所以需要设置一个队列，来保存等待连接的客户端
    // 队列的长度为 8，表示最多可以有 8 个客户端等待连接
    // listen(int sockfd, int backlog)
    // sockfd 就是之前创建的 socket 句柄
    // backlog 就是队列的长度
    // 返回值：成功返回 0，失败返回 -1
    if (::listen(_listensockfd, BACKLOG) < 0) {
        LOG(LogLevel::ERROR) << "listen socket error: " << strerror(errno);
        Die(4);
    }
    LOG(LogLevel::INFO) << "listen sockfd success: " << _listensockfd;
}

我们先将 Loop() 函数设计成死循环，验证一下 初始化函数 的正确性

// 测试
void Loop() {
    _isrunning = true;
    while (_isrunning) {
        sleep(1);
    }
    _isrunning = false;
}

在这里插入图片描述

2.5 循环监听

执行服务函数主要分为两步：

  1. 获取新连接 ( accept函数 [从已完成连接队列的头部返回下一个已完成连接，如果队列为空，则阻塞调用进程])

在这里插入图片描述
2. 执行服务 (前提是获取到新连接)

2.5.1 server 0 - 单执行流版本

工作机制：

  • 单线程通过while(1)循环依次处理每个客户端请求，处理完一个请求后才能处理下一个。

注意：tcp协议可以直接使用read，write函数读写文件描述符的内容(因为tcp是面向字节流的)！

// server - 0 单执行流版本
// ​工作机制：单线程通过while(1)循环依次处理每个客户端请求，处理完一个请求后才能处理下一个。
void Loop() {
    _isrunning = true;
    while (_isrunning) {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);

        // 1. 获取新连接
        int sockfd = ::accept(_listensockfd, CONV(&client), &len);
        if (sockfd < 0) {
            LOG(LogLevel::ERROR) << "accept socket error: " << strerror(errno);
            continue;
        }
        InetAddr cli(client);
        LOG(LogLevel::INFO) << "accept new connection from " << cli.AddrStr()
                            << " sockfd: " << sockfd;

        // 获取成功
        Server(sockfd, cli);
    }
}
void Server(int sockfd, InetAddr& cli) {
    // 长服务
    while (true) {
        char inbuffer[1024]; // 当作字符串
        // 1. 读文件
        // read
        // 函数的第一个参数是文件描述符，第二个参数是读入缓冲区，第三个参数是读入的字节数
        // 返回值：成功返回读入的字节数，失败返回 -1
        ssize_t n = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1);
        if (n > 0) {
            inbuffer[n] = 0;
            LOG(LogLevel::INFO)
                << "get msg from " << cli.AddrStr() << " msg: " << inbuffer;
            std::string echo_string = "[server echo]# ";
            echo_string += inbuffer;

            // 2. 写文件
            write(sockfd, echo_string.c_str(), echo_string.size());
        } else if (n == 0) {
            LOG(LogLevel::INFO) << "client " << cli.AddrStr() << " closed";
            break;
        } else {
            LOG(LogLevel::ERROR) << "read socket error: " << strerror(errno);
            break;
        }
    }
    ::close(sockfd);
}

2.5.2 server 1 - 多进程版本

​工作机制：

  • 父进程通过fork()为每个新连接创建子进程，子进程处理完请求后退出。
  • 但是进程创建/销毁开销大，​高并发时资源耗尽​
void Loop() {
    _isrunning = true;
    while (_isrunning) {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);

        // 1. 获取新连接
        int sockfd = ::accept(_listensockfd, CONV(&client), &len);
        if (sockfd < 0) {
            LOG(LogLevel::ERROR) << "accept socket error: " << strerror(errno);
            continue;
        }
        InetAddr cli(client);
        LOG(LogLevel::INFO) << "accept new connection from " << cli.AddrStr()
                            << " sockfd: " << sockfd;

        // 获取成功
        pid_t id = fork();
        if (id == 0) {              // 子进程
            ::close(_listensockfd); // 关闭监听套接字（子进程不需要监听）

            // 孙子进程的创建
            if (fork() > 0)
                exit(0); // 父进程（子进程）退出，孙子进程继续运行

            // 孙子进程执行实际服务逻辑
            Server(sockfd, cli);
            exit(0);
        }
        // 父进程（主进程）
        ::close(sockfd); // 关闭连接套接字（父进程不处理具体业务）
        int n = waitpid(id, nullptr, 0); // 等待子进程退出
        if (n > 0) {
            LOG(LogLevel::INFO) << "wait chid success";
        }
    }
    _isrunning = false;
}
void Server(int sockfd, InetAddr& cli) {
    // 长服务
    while (true) {
        char inbuffer[1024]; // 当作字符串
        // 1. 读文件
        // read
        // 函数的第一个参数是文件描述符，第二个参数是读入缓冲区，第三个参数是读入的字节数
        // 返回值：成功返回读入的字节数，失败返回 -1
        ssize_t n = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1);
        if (n > 0) {
            inbuffer[n] = 0;
            LOG(LogLevel::INFO)
                << "get msg from " << cli.AddrStr() << " msg: " << inbuffer;
            std::string echo_string = "[server echo]# ";
            echo_string += inbuffer;

            // 2. 写文件
            write(sockfd, echo_string.c_str(), echo_string.size());
        } else if (n == 0) {
            LOG(LogLevel::INFO) << "client " << cli.AddrStr() << " closed";
            break;
        } else {
            LOG(LogLevel::ERROR) << "read socket error: " << strerror(errno);
            break;
        }
    }
    ::close(sockfd);
}

双重 fork() 的核心目的

  1. ​避免僵尸进程​
    • 若子进程直接处理请求并退出，父进程需通过 waitpid 回收资源，否则子进程会成为僵尸进程。
    • 高并发场景下，父进程可能因频繁调用 waitpid 而阻塞，无法及时处理新连接。
  • ​解决方案：
    • 子进程创建孙子进程后立即退出，孙子进程成为 ​孤儿进程，由 init 进程（PID=1）接管并自动回收资源。
    • 父进程只需等待子进程（短暂存在）退出，避免阻塞。
  1. 父进程快速回到主循环
    • 父进程的 waitpid 仅需等待子进程（而非孙子进程），子进程退出速度极快（仅执行 fork() 和 exit()），父进程迅速返回 accept 循环。
    • 提升服务器并发处理能力。

2.5.3 server 2 - 多线程版本

​工作机制：

  • 为每个新连接分配独立的线程处理业务逻辑
  1. 主线程（Loop 函数）​通过 accept 循环监听新连接，为每个新连接创建线程（pthread_create）传递连接信息给子线程（通过 ThreadDate 结构体）
  2. 子线程（Execute 函数）​​调用 pthread_detach 分离自身（避免主线程调用 pthread_join）执行 Server 函数处理具体业务逻辑线程结束后自动释放资源（通过 delete td）
  3. 业务处理（Server 函数）​循环读取客户端数据（read），处理业务逻辑（示例中的回显服务），发送响应（write）关闭连接（close(sockfd)）
        // server - 2 多线程版本
        // 为每个新连接分配独立的线程处理业务逻辑
        // （Loop 函数）通过 accept 循环监听新连接，为每个新连接创建线程（pthread_create）传递连接信息给子线程（通过 ThreadDate 结构体）
        // （Execute 函数）​​调用 pthread_detach 分离自身（避免主线程调用 pthread_join）执行 Server 函数处理具体业务逻辑线程结束后自动释放资源（通过 delete td）
        // （Server 函数）​循环读取客户端数据（read），处理业务逻辑（示例中的回显服务），发送响应（write）关闭连接（close(sockfd)）
        void Loop(){
            _isrunning = true;
            while(_isrunning){
                struct sockaddr_in client;
                socklen_t len = sizeof(client);

                // 1. 获取新连接
                int sockfd = ::accept(_listensockfd, CONV(&client), &len);
                if(sockfd < 0){
                    LOG(LogLevel::ERROR) << "accept socket error: " << strerror(errno);
                    continue;
                }
                InetAddr cli(client);
                LOG(LogLevel::INFO) << "accept new connection from " << cli.AddrStr() << " sockfd: " << sockfd;

                // 获取成功
                pthread_t tid;
                ThreadDate* td = new ThreadDate(sockfd, this, cli);
                // pthread_create 第一个参数是线程id，第二个参数是线程属性，第三个参数是线程函数，第四个参数是线程函数参数
                pthread_create(&tid, nullptr, Execute, td);
            }
            _isrunning = false;
        }
        // 线程函数参数对象
        class ThreadDate{
            public:
                int _sockfd;
                TcpServer* _self;
                InetAddr _addr;
            public:
                ThreadDate(int sockfd, TcpServer* self, const InetAddr& addr)
                    : _sockfd(sockfd), _self(self), _addr(addr)
                {}
        };
        // 线程函数
        static void* Execute(void* args){
            ThreadDate* td = static_cast<ThreadDate*>(args);
            // 子线程结束后由系统自动回收资源，无需主线程调用 pthread_join
            pthread_detach(pthread_self()); // 分离新线程，无需主线程回收
            td->_self->Server(td->_sockfd, td->_addr);
            delete td;
            return nullptr;
        }
        void Server(int sockfd, InetAddr& cli){
            // 长服务
            while(true){
                char inbuffer[1024]; // 当作字符串
                // 1. 读文件
                // read 函数的第一个参数是文件描述符，第二个参数是读入缓冲区，第三个参数是读入的字节数
                // 返回值：成功返回读入的字节数，失败返回 -1
                ssize_t n = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1);
                if(n > 0){
                    inbuffer[n] = 0;
                    LOG(LogLevel::INFO) << "get msg from " << cli.AddrStr() << " msg: " << inbuffer;
                    std::string echo_string = "[server echo]# ";
                    echo_string += inbuffer;

                    // 2. 写文件
                    write(sockfd, echo_string.c_str(), echo_string.size());
                }
                else if(n == 0){
                    LOG(LogLevel::INFO) << "client " << cli.AddrStr() << " closed";
                    break;
                }
                else{
                    LOG(LogLevel::ERROR) << "read socket error: " << strerror(errno);
                    break;
                }
            }
            ::close(sockfd);
        }

2.5.4 server 3 - 内存池

将执行服务的函数入线程池队列，该函数需要是参数为空和返回值为void的函数，因此需要bind绑定函数！

using task_t = std::function<void(int sockfd, InetAddr& cli)>;

// server - 3 内存池版本
void Loop() {
    _isrunning = true;
    while (_isrunning) {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);

        // 1. 获取新连接
        int sockfd = ::accept(_listensockfd, CONV(&client), &len);
        if (sockfd < 0) {
            LOG(LogLevel::ERROR) << "accept socket error: " << strerror(errno);
            continue;
        }
        InetAddr cli(client);
        LOG(LogLevel::INFO) << "accept new connection from " << cli.AddrStr()
                            << " sockfd: " << sockfd;

        // 获取成功
        task_t task = std::bind(&TcpServer::Server, this, sockfd, cli);
        ThreadPool<task_t>::getInstance()->Equeue(task);
    }
    _isrunning = false;
}
void Server(int sockfd, InetAddr& cli) {
    // 长服务
    while (true) {
        char inbuffer[1024]; // 当作字符串
        // 1. 读文件
        // read
        // 函数的第一个参数是文件描述符，第二个参数是读入缓冲区，第三个参数是读入的字节数
        // 返回值：成功返回读入的字节数，失败返回 -1
        ssize_t n = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1);
        if (n > 0) {
            inbuffer[n] = 0;
            LOG(LogLevel::INFO)
                << "get msg from " << cli.AddrStr() << " msg: " << inbuffer;
            std::string echo_string = "[server echo]# ";
            echo_string += inbuffer;

            // 2. 写文件
            write(sockfd, echo_string.c_str(), echo_string.size());
        } else if (n == 0) {
            LOG(LogLevel::INFO) << "client " << cli.AddrStr() << " closed";
            break;
        } else {
            LOG(LogLevel::ERROR) << "read socket error: " << strerror(errno);
            break;
        }
    }
    ::close(sockfd);
}

🏳️‍🌈三、TcpClient.cpp

  1. ​创建Socket,调用 socket(AF_INET, SOCK_STREAM, 0) 创建TCP套接字。失败时打印错误并退出。
  2. ​设置服务器地址，通过 sockaddr_in 结构指定服务器的IP和端口。inet_pton 将字符串IP转换为网络字节序。
  3. 建立连接，调用 connect 主动连接服务器。失败时打印错误并退出。
  4. ​交互式通信，循环读取用户输入（如 hello）。通过 write 发送消息到服务器。通过 read 读取服务器回显的消息并显示。若服务器断开或读失败，退出循环。
  5. ​关闭连接，调用 close 关闭套接字。
#include "TcpClient.hpp"


int main(int argc, char* argv[]){
    if(argc != 3){
        std::cerr << "Usage: " << argv[0] << " <server_ip> <server_port>" << std::endl;
        Die(1);
    }

    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    // 1. 创建套接字
        // AF_INET: IPv4协议
        // SOCK_STREAM: TCP协议
        // 0: 表示默认协议
    int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0){
        std::cerr << "Create socket error: " << std::strerror(errno) << std::endl;
        Die(2);
    }

    // 2. 设置服务器地址
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;    // IPv4协议
    server.sin_port = htons(serverport); // 端口号
    // 这句话表示将字符串形式的IP地址转换为网络字节序的IP地址
    // inet_pton函数的作用是将点分十进制的IP地址转换为网络字节序的IP地址
    // 这里的AF_INET表示IPv4协议
    // 这里的serverip.c_str()表示IP地址的字符串形式
    // &server.sin_addr表示将IP地址存储到sin_addr成员变量中
    ::inet_pton(AF_INET, serverip.c_str(), &server.sin_addr);   // IP地址

    // 3. 与服务器建立连接
    int n = ::connect(sockfd, CONV(&server), sizeof(server));
    if(n < 0){
        std::cerr << "Connect error: " << std::strerror(errno) << std::endl;
        Die(5);
    }


    // 4. 发送消息
    while(true){
        std::string mag;
        std::cout << "Enter# ";
        std::getline(std::cin, mag);

        write(sockfd, mag.c_str(), mag.size());
        char echo_buf[1024];
        n = read(sockfd, echo_buf, sizeof(echo_buf));
        if(n > 0){
            echo_buf[n] = 0;
            std::cout << "Echo: " << echo_buf << std::endl;
        }
        else{
            break;
        }
    }

    // 5. 关闭套接字
    ::close(sockfd);


    return 0;
}

👥总结

本篇博文对 【Linux网络】各版本TCP服务器构建 - 从理解到实现 做了一个较为详细的介绍，不知道对你有没有帮助呢

觉得博主写得还不错的三连支持下吧！会继续努力的~

JhonKI
关注
【Linux】Socket编程-TCP构建自己的C++服务器
You build it, you run it
01-17 3630
详细讲解了在Linux下进行tcpsocket编程
【Linux网络编程】第七弹---构建类似XShell功能的TCP服务器：从TcpServer类到主程序的完整实现
小林熬夜学习编程的博客
12-08 5134
TcpServer.hpp：TcpServer类基本结构，Execute()；Command.hpp：Command类基本结构，构造析构函数，SafeCheck()，HandlerCommand()；TcpServerMain.cc；完整代码，TcpServer.hpp，Command.hpp，TcpServerMain.cc~~~
linux网络编程-多进程实现TCP并发服务器
天道酬勤
02-23 2600
• socket函数创建监听套接字lfd • bind函数将监听套接字绑定ip和端口 • listen函数设置服务器为被动监听状态，同时创建一条未完成连接队列（没走完tcp三次握手流程的连接），和一条已完成连接队列（已完成tcp三次握手的连接） • accept函数循环的从已完成连接队列中提取连接，并返回一个新的套接字cfd跟客户端进行通信 • fork函数创建一个子进程，让子进程与客户端进行通信 • 子进程：read函数循环的从r缓冲区读取客户端发送的数据，write函数将要发送的数据写入w缓冲区
【Linux网络编程】第六弹---构建TCP服务器：从基础到线程池版本的实现与测试详解
小林熬夜学习编程的博客
12-06 4167
TcpServerMain.cc；TcpServer.hpp：TcpServer类基本结构，构造析构函数，InitServer()；Loop()：Server 0(不靠谱版本)，Server 1(多进程版本)，Server 2(多线程版本)，Server 3(线程池版本)；TcpClientMain.cc；测试结果(4个版本)；完整代码：Makefile，TcpClientMain.cc，TcpServer.hpp，TcpServerMain.cc~~~
【Linux网络编程】TCP并发服务器的实现（IO多路复用select）
m0_65835264的博客
08-16 3279
TCP的服务器默认的就是一个循环服务器，原因是有两个阻塞 accept函数 和 recv函数之间会相互影响。本文是TCP并发服务器、客户端的实现以及实例的详细解释。使用了IO多路复用select函数进行TCP并发服务器的构建。希望博客对您有所帮助。 .........
Linux&C语言简单使用IO多路复用（select）实现TCP并发服务器-传输层
qq_47355554的博客
05-23 2620
IO多路复用实现TCP并发服务器 服务器模型分为两种，循环服务器、并发服务器。 循环服务器： 服务器在同一时刻只能处理同一个客户端的请求。 并发服务器： 服务器在同一时刻能处理多个客户端的请求。 TCP服务器默认的就是一个循环服务器，因为内部有两个阻塞的函数， accept recv 会相互影响 UDP服务器默认的就是一个并发服务器，因为只有一个阻塞的函数 recvfrom
Linux网络编程——简单基于TCP协议的服务器/客户端示例
weixin_42645653的博客
11-11 4665
说明：   本文章旨在总结备份、方便以后查询，由于是个人总结，如有不对，欢迎指正；另外，内容大部分来自网络、书籍、和各类手册，如若侵权请告知，马上删帖致歉。   QQ 群 号：513683159 【相互学习】 内容来源：   《Linux网络编程》 功能描述：   客户端连接服务器后从标准输入读取字符串发送给服务器。   服务器接收到字符串后，发送接收到的总字符串个数给客户端、   客户端将接受到的服务器信息打印到标准输出。   整个过程流程如下： 源文件 服务器端源文件：tcp_server.c /**
linux系统下的TCP网络编程
qq_44971750的博客
10-03 1505
linux系统下面的tcp网络编程学习记录
深入理解Linux网络——TCP连接建立过程（三次握手源码详解）
qq_25046827的博客
07-15 2833
icsk->icsk_accept_queue定义在inet_connection_sock下，是一个request_sock_queue类型的对象，是内核用来接收客户端请求的主要数据结构。我们平时说的全连接队列、半连接队列全都是在这个数据结构里实现的。我们来看具体的代码。// 全连接队列 struct request_sock * rskq_accept_head;// 半连接队列 struct listen_sock * listen_opt;
Linux基础网络编程：Linux环境下TCP服务器与客户端的搭建
weixin_45054387的博客
02-04 3619
在Linux下创建一个tcp服务器，有以下六个步骤： socket – 创建套接字 bind – 绑定主机和端口 listen --设置监听套接字 accept – 接收客户端连接，并生成新的套接字 read/write – 收发数据 close – 关闭套接字 简单介绍一下这几个函数： 1.socket：创建套接字 #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> int
易语言linux多进程tcp服务器源码-易语言
06-13
易语言Linux多进程TCP服务器源码是一个用于学习和实践网络编程的优秀资源，它结合了易语言和Linux操作系统，展示了如何构建一个支持多进程的TCP服务器。在这一领域，掌握多进程模型对于理解和优化服务器性能至关重要...
server-on-pc-linux.rar_linux TCP 服务器_linux tcp server_tcp server
09-14
本文将深入探讨如何在Linux上实现一个简单的TCP服务器，并通过分析提供的"server-on-pc-linux.c"源代码文件，了解其工作原理。 首先，创建一个TCP服务器需要理解以下几个核心概念： 1. **套接字（Socket）**：它是...
Sample-TCP-Server-Client.rar_linux client server_linux tcp clien
09-21
本示例提供的"Sample-TCP-Server-Client.rar"是一个简单的TCP服务器和客户端的实现，适用于Linux环境。通过分析其中的"server.c"和"client.c"源代码，我们可以深入理解TCP通信的基础和实现。 首先，TCP是一种面向...
同一无线网络下的设备IP地址是否相同？
hgdlip的博客
05-23 454
在家庭和办公网络普及的今天，许多人都会好奇：连接同一个Wi-Fi的设备是否共享相同的IP地址？这个问题看似简单，实则涉及多个角度。本文将为您揭示其中的技术奥秘。
第 4 章：网络与总线——CAN / Ethernet / USB-OTG
hemoparrot的专栏
05-20 883
本章深入探讨了三种关键通信总线（CAN、Ethernet、USB-OTG）的协议架构、硬件接口与软件驱动，重点介绍了在STM32微控制器中的寄存器配置、中断与DMA驱动框架。通过实战案例，展示了如何实现基于CAN总线的节点通信、基于Ethernet的TCP/IP通信，以及基于USB-OTG的虚拟串口与大容量存储访问。CAN总线适用于高可靠、实时要求的场景，Ethernet适合高带宽、远距离的网络互联，而USB-OTG则提供了即插即用的多功能接口。本章还提供了选型建议，帮助读者根据实际需求选择合适的通信总线，
计算机网络 第三章：运输层（二）
Zhang_Qin123的博客
05-22 1202
该分组经过。
K8S-statefulset-mysql-ha
demon7552003的小本本
05-24 249
本文介绍了在Kubernetes上部署MySQL高可用集群的方案
软件设计师考试需背诵知识点
lzfshub
05-21 244
本文简要介绍了网络技术中的几个关键概念。首先，网络技术标准与协议是确保设备间通信的基础。其次，OSI/RM七层模型为网络通信提供了分层的框架，便于理解和设计网络系统。在加密技术方面，对称加密算法和非对称加密算法分别用于数据加密和安全通信，其中对称加密速度快，非对称加密安全性高。最后，文章还比较了常见的排序算法，帮助理解不同算法在数据处理中的效率和应用场景。这些内容为网络技术和数据安全提供了基础知识和实用参考。
发电厂进阶，modbus TCP转ethernet ip网关如何赋能能源行业
最新发布
bjwljs的博客
05-24 297
发电厂智能化改造中，稳联技术WL-ABC2004网关实现ModbusTCP与EtherNet/IP协议转换，解决了500MW燃煤电厂30台除尘风机与控制系统间的通信难题。该工业级网关支持RS485电气隔离，适应高干扰环境，将传统设备接入现代控制系统，消除数据孤岛，助力电厂智能化升级，为能源行业转型提供关键技术支撑。
Linux网络编程基础：TCP服务器与客户端实现
"这篇资料主要介绍了Linux环境下的网络编程基础知识，包括TCP服务器和客户端的创建以及进程编程的相关练习。在进程编程部分，提到了进程创建与管理、命名管道与无名管道的应用，以及信号的接收和发送。在网络编程...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值