【网络】实现简单的TCP、UDP服务器、TCP多进程/多线程服务器

最新推荐文章于 2023-08-18 20:45:53 发布
最新推荐文章于 2023-08-18 20:45:53 发布
阅读量3.1k 收藏 9
点赞数 2
分类专栏： 计算机网络 文章标签： UDP服务器 TCP多进程-多线程 socket套接字
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinghe0808/article/details/74599575
版权

1.0 一个简单的TCP服务器（只服务一个客户端）

先看代码如下：
server.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>

static void Usage(const char* proc)
{
    printf("Usage:%s[local_ip][local_port]\n",proc);
}


int StartUp(const char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(sock < 0){
        perror("socket");
        exit(2);
    }   

    struct sockaddr_in local;//IPV4
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){//绑定套接字
        perror("bind");
        exit(3);
    }

    if(listen(sock,5) < 0){//监听套接字
        perror("listen");
        exit(4);
    }

    return sock;//将最终得到的监听套接字返回
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int listen_sock = StartUp(argv[1],atoi(argv[2]));//获得监听套接字
    while(1)
    {
        struct sockaddr_in client;//用来获得发送者的信息（ip地址和端口号）
        socklen_t len = sizeof(client);

        //建立连接，得到新套接字进行操作
        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
        if(new_sock < 0){
            perror("accept");//if fail,again listen
            continue;
        }

        printf("get a connect,ip is %s,port is %u\n",\
              inet_ntoa(client.sin_addr),ntohs(client.sin_port));

        while(1)
        {//先读再写
         char buf[1024];
         ssize_t s = read(new_sock,buf,sizeof(buf)-1);

         if(s > 0){//读成功
            buf[s] = '\0';
            printf("client#:%s\n",buf);
            write(new_sock,buf,strlen(buf));//server hui xian
         }
         else if(s == 0){//读到的字节数为0，表明对端结束已经关闭
            printf("client exit\n");
            break;
         }
         else{//读失败
            perror("read");
            break;

          }

        }

        close(new_sock);
    }
    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

static Usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_prot]\n",proc);
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(sock < 0){
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0){//请求与服务器建立TCP连接
        perror("connect");
        return 3;
    }

    while(1)
    {//先写在读
     printf("client#");
     fflush(stdout);
     char buf[1024];
     ssize_t s = read(0,buf,sizeof(buf)-1);//从标准输入（键盘）中读数据到buf
     if(s > 0){
         buf[s-1] = '\0';
         write(sock,buf,strlen(buf));
         ssize_t _s = read(sock,buf,sizeof(buf)-1);//实现服务器的回显
         if(_s > 0){
         buf[_s] = '\0';
         printf("server echo#%s\n",buf);
         }
    }
     else if(s == 0){
         printf("read ending\n");
         exit(4);
     }
     else{
         perror("read");
         break;
     }
    }
    return 0;
}

····第一次连接的现象
client.c
这里写图片描述

server.c
这里写图片描述

·····client.c结束后的现象
client.c
这里写图片描述

server.c
这里写图片描述

····再次重新连接后的现象
client.c
这里写图片描述

server.c
这里写图片描述

但是有个问题，上面实现的简单服务器，每次只能连接一个客户端，当有多个客户端同时请求与服务器连接时，服务器只能处理一个的请求与一个客户端相连，剩下的连接请求先阻塞在连接队列，当服务器处理完某个客户端的连接，再从队列里拿一个连接进行处理。如下。

37161端口
这里写图片描述

37162端口
这里写图片描述

服务器处理完37161，才处理37162，因为服务器在处理37161的时候，37162给服务器发消息，服务器不作回应。
这里写图片描述

但是只能进行一对一的连接，与我们平常所见到的服务器功能不符，单进程的服务器毕竟来说可服务的对象就很小，所以现在实现一个多进程的服务器。那么接下来我们来实现一个一对多的服务器。

2.0 实现TCP多进程服务器

server.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<fcntl.h>
#include<arpa/inet.h>
#include<netinet/in.h>

static void Usage(const char* proc)
{
    printf("Usage:%s[local_ip][local_port]\n",proc);
}


int StartUp(const char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);//create socket
    if(sock < 0){
        perror("socket");
        exit(2);
    }   

    struct sockaddr_in local;//IPV4
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){//bind
        perror("bind");
        exit(3);
    }

    if(listen(sock,10) < 0){//listen
        perror("listen");
        exit(4);
    }

    return sock;//return an "listen_sock";
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int listen_sock = StartUp(argv[1],atoi(argv[2]));//get listen_sock
    while(1)
    {
        struct sockaddr_in client;//get sender's information
        socklen_t len = sizeof(client);

        //get real socket that we will operator
        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
        if(new_sock < 0){
            perror("accept");//if fail,again listen
            continue;
        }

        printf("get a connect,ip is %s,port is %u\n",\
              inet_ntoa(client.sin_addr),ntohs(client.sin_port));

        pid_t id = fork();
        if(id < 0){
            perror("fork");
            close(new_sock);
        }
        else if(id == 0)
        {//child
            close(listen_sock);
            if(fork() > 0){//again fork , create sun zi process and child process end
             exit(0);
             }   

            //sun zi process working
            while(1)
            {//first read,then write
             char buf[1024];
             ssize_t s = read(new_sock,buf,sizeof(buf)-1);

             if(s > 0){//read successful
                 buf[s] = '\0';
                 printf("client#:%s\n",buf);
                 write(new_sock,buf,strlen(buf));//server hui xian
             }
             else if(s == 0){//read to file's end
                 printf("client exit\n");
                 break;
             }
             else{//read fail
                 perror("read");
                 break;
             }
            }
             close(new_sock);
             exit(0);
        }
        else
        {//father
         close(new_sock);
         waitpid(id,NULL,0);
        }
    }
    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<fcntl.h>
#include<netinet/in.h>
#include<arpa/inet.h>

static Usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_prot]\n",proc);
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);//create socket
    if(sock < 0){
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0){//connect
        perror("connect");
        return 3;
    }

    while(1)
    {//first write,then read
         printf("client#");
         fflush(stdout);
         char buf[1024];
         ssize_t s = read(0,buf,sizeof(buf)-1);//read data from stdin
         if(s > 0){
             buf[s-1] = '\0';
             write(sock,buf,strlen(buf));
             ssize_t _s = read(sock,buf,sizeof(buf)-1);//shi xian server hui xian
             if(_s > 0){
             buf[_s] = '\0';
             printf("server echo#%s\n",buf);
            }
        }
         else if(s == 0){
             printf("read ending\n");
             exit(4);
         }
         else{
             perror("read");
             break;
         }
    }
    close(sock);
    return 0;
}

    在server.c中，我们先fock了两个进程父进程和子进程。父进程的工作是不断地返回accept处拿new_sock,子进程的工作是不断地去处理new_sock。也就是说父进程只管拿，子进程只管处理。所以父进程关闭不需要的套接字new_sock,而只留下listen_sock ； 子进程关闭不需要的listen_sock,而留下new_sock.
    细心地你也许会发现，可是为什么还在子进程中再次fock创建一个孙子进程?这也正是这段代码的巧妙之处。
     通过之前的学习我们知道，子进程退出后变成僵尸进程，直到父进程调用wait或者waitpid来对子进程资源进行回收。所以在第一次fork完成后，我们父进程会调用waitpid等待函数去等待子进程结束，但是它目前是阻塞式等待。为了解决阻塞问题，我们在子进程中又创建了一个孙子进程，并且让子进程退出，让孙子进程去完成子进程的工作。而对于孙子进程来说，子进程的退出使孙子进程变成孤儿进程，被1号进程Init收养，若孙子进程退出也是由Init进程回收它，与父进程中的waitpid无关。这样当子进程退出时，父进程的waitpid对子进程资源进行了回收，并且回收后因为子进程已经不存在了，waitpid也失去了它的作用，就不会阻塞了。这就是这段代码的巧妙之处。

结果如图：
client1
这里写图片描述

client2
这里写图片描述

server
这里写图片描述

3.0 实现TCP多线程服务器
基于多线程的服务器和多进程的差不多。代码如下。
server.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<fcntl.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<pthread.h>

static void Usage(const char* proc)
{
    printf("Usage:%s[local_ip][local_port]\n",proc);
}


int StartUp(const char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);//create socket
    if(sock < 0){
        perror("socket");
        exit(2);
    }   

    struct sockaddr_in local;//IPV4
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){//bind
        perror("bind");
        exit(3);
    }

    if(listen(sock,10) < 0){//listen
        perror("listen");
        exit(4);
    }

    return sock;//return an "listen_sock";
}

void* request(void* arg)
{
    int new_sock = (int)arg;
    printf("get a new client\n");
    while(1)
    {//first read,then write
     char buf[1024];
     ssize_t s = read(new_sock,buf,sizeof(buf)-1);

     if(s > 0){//read successful
         buf[s] = '\0';
         printf("client#:%s\n",buf);
         write(new_sock,buf,strlen(buf));//server hui xian
     }
     else if(s == 0){//read to file's end
         printf("client exit\n");
         break;
     }
     else{//read fail
         perror("read");
         break;
     }
    }


}
int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int listen_sock = StartUp(argv[1],atoi(argv[2]));//get listen_sock

    while(1)
    {
        struct sockaddr_in client;//get sender's information
        socklen_t len = sizeof(client);

        //get real socket that we will operator
        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
        if(new_sock < 0){
            perror("accept");//if fail,again listen
            continue;
        }

        pthread_t id;
        pthread_create(&id,NULL,&request,(void*)new_sock);
        pthread_detach(id);
    }


    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<fcntl.h>
#include<netinet/in.h>
#include<arpa/inet.h>

static Usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_prot]\n",proc);
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);//create socket
    if(sock < 0){
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0){//connect
        perror("connect");
        return 3;
    }

    while(1)
    {//first write,then read
         printf("client#");
         fflush(stdout);
         char buf[1024];
         ssize_t s = read(0,buf,sizeof(buf)-1);//read data from stdin
         if(s > 0){
             buf[s-1] = '\0';
             write(sock,buf,strlen(buf));
             ssize_t _s = read(sock,buf,sizeof(buf)-1);//shi xian server hui xian
             if(_s > 0){
             buf[_s] = '\0';
             printf("server echo#%s\n",buf);
            }
        }
         else if(s == 0){
             printf("read ending\n");
             exit(4);
         }
         else{
             perror("read");
             break;
         }
    }
    close(sock);
    return 0;
}

thread1
这里写图片描述

thread2
这里写图片描述

server
这里写图片描述

4.0 实现UDP服务器

UDP服务器进行读写时，用的不是read和write，而是以下两个函数。

#include <sys/socket.h>

ssize_t recvfrom(int sockfd, void *buff, size_t nbytes, int flags, struct sockaddr *from, socklen_t *addrlen);

ssize_t sendto(int sockfd, const void *buff, size_t nbytes, int flags, const struct sockaddr *to, socklen_t addrlen);
//均返回：若成功则为读或写的字节数，出错为-1

    前三个参数：sockfd, buff, nbytes等同于read和write的前三个参数：描述字，指向读入或者写出缓冲区的指针，读写字节数。
    函数sendto的参数to是一个含有数据将发往的协议地址(例如IP地址和端口号)的套接口地址结构，它的大小由addrlen来指定。函数recvfrom用数据报发送者的协议地址装填由from所指的套接口地址结构，存储在此套接口地址结构中的字节数也以addrlen所指的整数返回给调用者。注意，sendto的最后一个参数是一个整数值，而recvfrom的最后一个参数值是一个指向整数值的指针。
    recvfrom的最后两个参数类似于accept的最后两个参数：返回时套接口地址结构的内容告诉我们是谁发送了数据报(UDP情况下)或是谁发起了连接(TCP情况下)。sendto的最后两个参数类似于connect的最后两个参数：我们用数据报将发往(UDP情况下)或与之建立连接(TCP情况下)的协议地址来装填套接口地址结构。
    写一个长度为0的数据报是可行的，这也意味着对于数据报协议，recvfrom返回0值也是可行的；它不表示对方已经关闭了连接，这与TCP套接口上的read返回0的情况不同。由于UDP服务器也是服务器，所以需要绑定，但因为UDP是无连接的，所以不需要监听和连接，这就没有诸如关闭UDP连接之类的事情。
    PS：默认情况recvfrom函数没有接收到对方数据时候是阻塞的

实现代码如下：
server.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<fcntl.h>
#include<arpa/inet.h>
#include<netinet/in.h>


static void Usage(const char* proc)
{
    printf("Usage:%s[local_ip][local_port]\n",proc);
}


int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_DGRAM,0);//create socket
    if(sock < 0){
        perror("socket");
        exit(2);
    }   

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[2]));
    local.sin_addr.s_addr = inet_addr(argv[1]);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){//bind
        perror("bind");
        exit(3);
    }

    printf("get a client\n");
    while(1)
    {//先读再写
        printf("[%s:%d]\n",inet_ntoa(local.sin_addr),ntohs(local.sin_port));
        struct sockaddr_in client;//获得发送方的信心（ip地址和端口号）
        socklen_t len = sizeof(client);

        char buf[1024];
        int s  = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&client,&len);//与accept相似
        if(s < 0){
            perror("recvfrom");
            continue;
        }
        else if(s > 0){
            buf[s] = '\0';
            printf("[%s:%d]# %s\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port),buf);
            sendto(sock,buf,strlen(buf),0,(struct sockaddr*)&client,sizeof(client));//sendto类似于connect,这一步是在进行服务器回显
        }
        else{
            printf("client exit!\n");
            continue;
        }
    }


    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<fcntl.h>
#include<netinet/in.h>
#include<arpa/inet.h>

static Usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_prot]\n",proc);
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_DGRAM,0);//create socket
    if(sock < 0){
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    while(1)
    {//先写再读
         printf("client#");
         fflush(stdout);
         char buf[1024];

         struct sockaddr_in peer;
         socklen_t len = sizeof(peer);

         ssize_t s = read(0,buf,sizeof(buf)-1);
         if(s > 0){
             buf[s-1] = '\0';
             sendto(sock,buf,strlen(buf),0,(struct sockaddr*)&server,sizeof(server));
             ssize_t _s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&peer,&len);//实现服务器回显
             if(_s > 0){
             buf[_s] = '\0';
             printf("[%s:%d]:%s\n",inet_ntoa(peer.sin_addr),ntohs(peer.sin_port),buf);
            }
        }
         else if(s == 0){
             printf("read ending\n");
             exit(4);
         }
         else{
             perror("read");
             break;
         }
    }
    close(sock);
    return 0;
}

client1
这里写图片描述

client2
这里写图片描述

server
这里写图片描述

qinghe0808
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络通信，其中包括UDP通信，TCP通信，多进程，多线程，手动搭建服务器，文件下载源码
07-06
网络通信，其中包括UDP通信，TCP通信，多进程，多线程，手动搭建服务器，文件下载源码，都是基础版的。
多进程多线程并发服务器&&本地通讯（TCP、UDP）
qq_45996420的博客
08-16 352
多进程多线程并发服务器&&本地通讯（TCP、UDP）
主机到主机层(OSI称为传输层)提供的两个主要服务------TCP和UDP简要总结
ZhangPengFeiToWinner的博客
11-27 3128
1.TCP:传输控制协议，TCP向应用提供了可靠的、面向连接的服务(也就是我们一般称为的可靠传输协议)。 源端口和目标端口:字段长度各16位，它们为封装的数据指定了源和目的应用程序。 序列号:字段长度32位，序列号确定发送方发送的数据流中被封装的数据所在的位置。 确认号:字段长度32位，确认号确定了源点下一次希望从目标接受的序列号。 报头长度:又叫数据偏移量，4位，指定了以32位为单位的报头长度...
第16章 网络编程
MObaiYUhai的博客
10-14 130
16.4 TCP网络通信 16.4.1 通讯要素2：网络通信协议 网络通信协议 计算机网络中实现通信必须有一些约定，即通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。 通信协议分层的思想 由于结点之间联系很复杂，在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不...
【Linux网络（C++)】——网络套接字（TCP/UDP编程模型）多进程，多线程，线程池服务器开发（画图解析）
sjp11的博客
02-22 5035
TCP/IP协议传输层的主要任务是向位于不同的（有时候位于同一主机）上的应用程序提供端到端的通信服务，为了区分应用程序，TCP和UDP引入了端口号的概念。 端口号 端口号（port）是传输层协议的内容 是一个2字节的16位整数。 端口号是用来表示进程的，告诉操作系统，当前的数据要交给哪一个进程处理 ip地址+端口号能够标识网络上一台主机上的一个进程。 一个端口号只能标识一个进程 在同一台机器上，进程的间的端口号都是不同的。 任何的网络服务与网络客户端，如果要进行正常的数据通信，必须使用..
TCP、UDP的传输及多线程多进程传输
Z_JUAN1的博客
08-07 3053
网络基础的讲解： https://blog.csdn.net/Z_JUAN1/article/details/81281606   socket常见API      从应用层到传输层有一个接口：socket API 接口      因此不管是服务器还是客户端在通信时都需要创建socket 一、这是UDP socket的流程 服务器整体思想：     创建socket，绑定地址端...
TCP和UDP套接字_简单的客户/服务器
06-10
设计简单的客户/服务器，服务器实现并发同时响应客户的UDP通信要求，也能响应客户端发过来的TCP通信要求。
C#实现多线程TCPUDP端口扫描
06-18
计算机信息网络的发展加速了信息化时代的进程，但是随着社会网络化程度的增加，对计算机网络的依赖也越来越大，网络安全问题也日益明显。端口扫描技术是发现安全问题的重要手段之一。一个端口就是一个潜在的通信通道...
服务器客户端-socket（进程线程）
10-13
服务器客户端-socket（进程线程），包括套接字，多线程，多进程，单进程，并发，互斥锁，tcp/ip,udp等
Linux下的多进程/线程网络通信
01-02
在客户端，设计两个进程P1和P2同时读取网卡上的数据，P1读取数据后，负责将TCP报文中的头部数据写入到Packet文件中，P2读取数据后，负责将UDP报文的头部同样写入到Packet文件中。另外，还需要将数据发送到服务器端...
基于UDP、TCP、多线程的socket编程
12-16
分别用UDP、TCP、多线程通信三种方式实现socket编程，是学习socket编程最全的小项目，是linux高级编程学习必须部分，现在我工作基本天天都跟他们打交道
C采用多线程和多进程实现TCP/UDP网络连接
Nuan_Feng的博客
09-28 1125
文章目录基础版多进程版本多线程版本 基础版 封装的socket.h warp_socket.h #ifndef _WRAP__ #define _WRAP__ #include <sys/socket.h> #define SOCKET_ERROR "socket error" #define CONNECT_ERROR "connect error" #define LISTEN_ERROR "listen error" #define BIND_ERROR "bind error
UDP协议与TCP协议的区别
wwy0324的博客
11-01 2367
一、UDP的概述 User Datagram Protocol，用户数据报协议 UDP是传输层的协议，功能即为在IP的数据报服务之上增加了最基本的服务：复用和分用以及差错检测。 二、UDP协议与TCP协议的区别 TCP连接时需要三次握手，有时间延迟，但是可靠；而UDP无连接，时间上不存在建立连接需要的时延,但是不可靠。 空间上，TCP需要在端系统中维护连接状态，需要一定的开销。此连接装入包括接收和发送缓存，拥塞控制参数和序号与确认号的参数。UCP不维护连接状态，也不跟踪参数，开销小。 举个例子：
TCP服务器实现—多进程版，多线程版，线程池版
终为nullptr
08-18 2034
TCP服务器实现—多进程版，多线程版，线程
【网络篇】第八篇——多进程版的TCP网络程序
m0_58367586的博客
11-13 673
之前我们已经利用socket编程实现了一个单进程的TCP网络程序(tcp详解),但上一章遗留了一个问题，当我们再开启一个终端去连接服务端，可以发现的是第二个客户端不能和服务器正常通信了，除非我们第一个客户端退出之后，第二个客户端才能和服务器正常通信。可以注意到大部分的socket接口都是阻塞型的。
Linux C/C++ 多线程TCP/UDP服务器 (监控系统状态)
chen1415886044的博客
02-19 2148
Linux环境中实现并发TCP/IP服务器。多线程在解决方案中提供了并发性。由于并发性，它允许多个客户端同时连接到服务器并与服务器交互。
UDP并发服务器思路
code_peak
07-14 3209
UDP并发与TCP并发的区别 在TCP并发编程中，通常使用one loop per thread的并发模型，也就是使用多个线程，每个线程中都有一个epoll loop，无论是使用epoll还是poll或select，在观察有无数据就绪时，都是针对多个文件描述符。如果只有一个文件描述符，那么进程只要观察那一个文件描述符即可。 网络编程中，一个Socket对应一个文件描述符。在TCP的并发中，服务器在监听端口初始化一个socket套接字描述符，接受客户端后就与每个客户端的连接有一个不同的文件描述符，所以TCP并
TCP并发服务器（多进程）
augeksjsj的博客
01-05 185
每连接一个客户端就fork一个子进程去处理，子进程结束，父进程要给子进程回收资源，假如是wait阻塞回收，不满足并发服务器要求。假如是waitpid非阻塞，轮询占资源。可以在子进程结束后给父进程发信号，父进程收到信号进行捕获，给子进程回收资源。
tcp服务器端 多对一
最新发布
08-31
因此，虽然TCP本身是一对一的，但通过多线程或多进程的方式，TCP服务器端可以实现多对一的连接。每个连接都有独立的套接字，利用不同的端口与不同的客户端进行通信。<span class="em">1</span><span class="em">2</...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值