TCP和UDP与IO模型

最新推荐文章于 2021-08-05 11:12:12 发布
最新推荐文章于 2021-08-05 11:12:12 发布
阅读量324 收藏 1
点赞数
分类专栏： # Linux 文章标签： tcpip udp io模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BluseLIBB/article/details/100149959
版权

TCP和UDP与IO模型

关键词： tcp udp

主要内容：

  • tcp
  • udp
  • tcp 多路复用
  • udp 非阻塞

文档参考：

最新地址： https://taotaodiy-linux.readthedocs.io/en/latest/linux/base/tcpudp.html

tcp 实现代码 (C语言)

TCP通信模型

一对一通信代码

客户端

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
int main(void)
{
    int cli_socket;
    int ret;
    struct sockaddr_in serv_addr;
    char buf[128];
    /*
        #include <sys/types.h>           
        #include <sys/socket.h>
            int socket(int domain, int type, int protocol);

            domain:
                AF_UNIX     进程间通信 socket
                    AF_INET     ipv4  通信
                AF_PACKET  原始套接字
            type:
                SOCK_STREAM  流式套接字   tcp通信
                SOCK_DGRAM  数据包套接字  udp通信
                SOCK_RAW    原始套接字
            protocol
                0
    */
    cli_socket = socket(AF_INET,SOCK_STREAM,0);
    if(cli_socket < 0){
        perror("socket err");
        return -34;
    }
    /*向服务器 发起连接请求
        connect
    #include <sys/types.h>           
    #include <sys/socket.h>
    int connect(int sockfd, const struct sockaddr *addr,
                socklen_t addrlen);
            struct sockaddr_in {
            sa_family_t    sin_family;    AF_INET  
            in_port_t      sin_port;    port 16bit   网络字节序  
            struct in_addr sin_addr;     internet address  ip地址
        };
            Internet address. 
        struct in_addr {
            uint32_t       s_addr;      address in network byte order  
        };
    */
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8888);
    serv_addr.sin_addr.s_addr = inet_addr("132.232.72.168");
    ret = connect(cli_socket, (struct sockaddr *)&serv_addr,sizeof(serv_addr));
    if(ret < 0 ){
        perror("connect err");
        return -34;
    }
    while(1){
        memset(buf,0,sizeof(buf));
        //strcpy(buf,"hello ,this is cli  msg!");
        scanf("%s", buf);
        ret = send(cli_socket,buf,sizeof(buf),0);
        if(ret <0){
            perror("cli send err");
            return -31;
        }
        memset(buf,0,sizeof(buf));
        ret = recv(cli_socket,buf,sizeof(buf),0);
        if(ret <0){
            perror("recv err");
            return -322;
        }
        if(ret == 0){
            printf("cli  recv get 0\n");
            return -345;
        }
        printf("cli get serv msg:%s\n",buf);
        sleep(1);
    }
    close(cli_socket);
}

服务器端

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
int main(void)
{
    int listen_socket;
    int cli_socket;
    int ret;
    struct sockaddr_in serv_addr;
    char buf[128];
    /*
        #include <sys/types.h>           
        #include <sys/socket.h>
            int socket(int domain, int type, int protocol);
            domain:
                AF_UNIX     进程间通信 socket
                    AF_INET     ipv4  通信
                AF_PACKET  原始套接字
            type:
                SOCK_STREAM  流式套接字   tcp通信
                SOCK_DGRAM  数据包套接字  udp通信
                SOCK_RAW    原始套接字
            protocol
                0
    */
    listen_socket = socket(AF_INET,SOCK_STREAM,0);
    if(listen_socket < 0){
        perror("socket err");
        return -34;
    }
    /*
    给socket 指定 ip和端口号

        int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

                struct sockaddr_in {
                    sa_family_t   sin_family;    AF_INET  
                    in_port_t     sin_port;    port 16bit   网络字节序  
                    struct in_addr sin_addr;     internet address  ip地址
                };

                Internet address. 
                struct in_addr {
                    uint32_t      s_addr;      address in network byte order  
                };
    */
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8888);
    //serv_addr.sin_addr.s_addr = inet_addr("132.232.72.168");
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    ret = bind(listen_socket,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    if(ret <0){
        perror("bind err");
        return -34;
    }
    /*
        int listen(int sockfd, int backlog);
        backlog:
            同一个瞬间,可以同时处理多少个请求 
            2*backlog+1
    */
    ret = listen(listen_socket,5);
    if(ret <0){
        perror("listen err");
        return -34;
    }
    /*当有 客户端连接上来的时候,accept 返回
        返回一个 新的socket,该新的socket 用于和客户端通信,表示一个新的连接

        int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        addr:  对方/客户端的 ip地址和端口

    */
    cli_socket = accept(listen_socket,NULL,NULL);
    if(cli_socket <0){
        perror("accept err");
        return -23;
    }
    while(1){
        /*
        服务器, 先收后发
        ssize_t recv(int sockfd, void *buf, size_t len, int flags);
        sockfd:通信socket
        buf:接收的数据存放的位置
        len: 你要求收取多少数据
        flags:  0

        返回值,
            >0 实际收取的大小
            =0 
            <0  表示收取失败
        */
        memset(buf,0,sizeof(buf));
        ret = recv(cli_socket,buf,sizeof(buf),0);
        if(ret<0){
            printf("recv err %d\n",errno);
            return -25;
        }
        if(ret == 0){
            printf("recv ==0 \n");
            return -34;
        }

        printf("serv get data:%s\n",buf);
        /*解析数据*/
        memset(buf,0,sizeof(buf));
        strcpy(buf,"Ur MSG got, this is server!");

        ret = send(cli_socket,buf,sizeof(buf),0);
        if(ret<0){
            printf("send err %d\n",errno);
            return -25;
        }

    }
    close(cli_socket);
}

comm.h 放传输数据用的结构体(也就是所谓的协议)

#ifndef  COMM_HHH_H
#define COMM_HHH_H

struct msg {
    char type;
    short sval;
    int  ival;
    char des[128];
};

#endif

makefile

all:
    gcc client.c  -o client
    gcc server.c -o server

一对多通信代码

一对多通信 主要是服务器代码不同，这里用多线程

服务器端

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include "comm.h"
struct  pri {
    pthread_t pid;
    int socket;
    int xpid;
    //...................
};
void *serv_for_cli (void *args)
{
    int ret;
    struct  pri *pri = args;
    int cli_socket = pri->socket;
    struct msg msg;
    while(1){
        memset(&msg,0,sizeof(msg));
        ret = recv(cli_socket,&msg,sizeof(msg),0);
        if(ret<0){
            printf("recv err %d\n",errno);
            goto end;
        }
        if(ret == 0){
            printf("recv ==0  peer client shutdown!!!!\n");
            goto end;
        }

        printf("serv get type%d sval%d ival%d des:%s\n",
            msg.type,ntohs(msg.sval), ntohl(msg.ival),msg.des);
        /*解析数据*/
        msg.type++;

        msg.sval = ntohs(msg.sval);
        msg.sval++;
        msg.sval = htons(msg.sval);
        strcpy(msg.des,"Ur MSG got, this is server!");

        ret = send(cli_socket,&msg,sizeof(msg),0);
        if(ret<0){
            printf("send err %d\n",errno);
            goto end;
        }
    }

end:
    free(pri);
    close(cli_socket);
    return NULL;
}
int main(void)
{
    int listen_socket;
    int cli_socket;
    int ret;
    struct pri *pri;

    struct sockaddr_in serv_addr;
    struct sockaddr_in cli_addr;
    socklen_t len;
    listen_socket = socket(AF_INET,SOCK_STREAM,0);
    if(listen_socket < 0){
        perror("socket err");
        return -34;
    }
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(3100);
    //serv_addr.sin_addr.s_addr = inet_addr("192.168.2.92");    //指定服务器ip
    serv_addr.sin_addr.s_addr = INADDR_ANY;         //给一个0,bind发现 ip为0,则自动获取主机ip地址
    ret = bind(listen_socket,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    if(ret <0){
        perror("bind err");
        return -34;
    }
    ret = listen(listen_socket,5);
    if(ret <0){
        perror("listen err");
        return -34;
    }
loop:
    len = sizeof(cli_addr);
    memset(&cli_addr,0,sizeof(cli_addr));
    cli_socket = accept(listen_socket,(struct sockaddr *)&cli_addr,&len);
    if(cli_socket <0){
        perror("accept err");
        return -23;
    }
    printf("serv get client  conncet: cli ip %s  port %d\n",
            inet_ntoa(cli_addr.sin_addr),  ntohs(cli_addr.sin_port)  );
    pri = malloc(sizeof(*pri));
    pri->socket = cli_socket;
    pthread_create(&pri->pid, NULL,serv_for_cli,pri);
    goto loop;
    close(listen_socket);
}

udp 实现代码 (C语言)

DUP通信模型{.align-center}

客户端

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "comm.h"
int main(void)
{
    int ret;
    int cli_socket;
    socklen_t addrlen;
    struct sockaddr_in serv_addr;
    struct  msg msg;
    cli_socket = socket(AF_INET,SOCK_DGRAM, 0);
    if(cli_socket < 0 ){
        perror("udp serv socket err");
        return -34;
    }
    memset(&msg,0,sizeof(msg));
    msg.type = 0;
    msg.sval = 12;
    msg.ival = 124;
    strcpy(msg.des,"hello comes from cli");
    while(1){
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(3100);
        serv_addr.sin_addr.s_addr = inet_addr("192.168.2.92");
        ret = sendto(cli_socket,&msg,sizeof(msg),0,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
        if(ret < 0){
            printf("sendto err%d\n",ret);
            return -34;
        }
        memset(&msg,0,sizeof(msg));
        addrlen = sizeof(serv_addr);
        ret = recvfrom(cli_socket, &msg, sizeof(msg), 0,(struct sockaddr *)&serv_addr, &addrlen);
        if(ret <=0){
            printf("recvfrom err%d\n",ret);
            return -34;
        }
        printf("cli get msg: type%d sval%d ival%d des:%s\n",
            msg.type,msg.sval,msg.ival,msg.des);
        sleep(1);   
    }
}

服务器端

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "comm.h"
int main(void)
{
    int ret;
    int serv_socket;
    struct sockaddr_in serv_addr;
    struct sockaddr cli_addr;
    socklen_t  addrlen;
    struct  msg msg;
/*
        int socket(int domain, int type, int protocol);
        domain:
            AF_UNIX     进程间通信 socket
                AF_INET     ipv4  通信
            AF_PACKET  原始套接字
        type:
            SOCK_STREAM  流式套接字   tcp通信
            SOCK_DGRAM  数据包套接字  udp通信
            SOCK_RAW    原始套接字
        protocol
            0
*/
    serv_socket = socket(AF_INET,SOCK_DGRAM, 0);
    if(serv_socket < 0 ){
        perror("udp serv socket err");
        return -34;
    }
/*
    给socket 指定 ip和端口号
    int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
            struct sockaddr_in {
                sa_family_t   sin_family;    AF_INET  
                in_port_t     sin_port;    port 16bit   网络字节序   
                struct in_addr sin_addr;    internet address  ip地址
            };
            Internet address. 
            struct in_addr {
                uint32_t      s_addr;      address in network byte order  
            };
*/
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(3100);
    serv_addr.sin_addr.s_addr = INADDR_ANY;         //给一个0,bind发现 ip为0,则自动获取主机ip地址
    ret = bind(serv_socket,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    if(ret <0){
        perror("bind err");
        return -34;
    }
    while(1){
    /*
    ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                            struct sockaddr *src_addr, socklen_t *addrlen);
    buf,len 用于存放接收到的数据
    src_addr,存放对方/客户端 的地址
    addrlen, 双向参数  你要告诉recvfrom 你的地址长度有多大,  该函数返回,告诉你真实的长度是多少
    返回值
            >=0 正确接收到的数据
            <0   出错
    */
        memset(&msg,0,sizeof(msg));
        addrlen = sizeof(cli_addr);
        ret = recvfrom(serv_socket, &msg, sizeof(msg), 0,&cli_addr, &addrlen);
        if(ret <=0){
            printf("recvfrom err%d\n",ret);
            return -34;
        }
        printf("serv get msg: type%d sval%d ival%d des:%s\n",
            msg.type,msg.sval,msg.ival,msg.des);
        msg.type++;
        msg.sval++;
        /*
        ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                                const struct sockaddr *dest_addr, socklen_t addrlen);
        */
        ret = sendto(serv_socket,&msg,sizeof(msg),0,&cli_addr,sizeof(cli_addr));
        if(ret < 0){
            printf("sendto err%d\n",ret);
            return -34;
        }
    }
}

tcp的多路复用(C语言)

普通tcp和udp使用就是同步阻塞，recv()、recvfrom()等函数就是阻塞死等；
这里主要是
套接字的非阻塞和tcp的多路复用，udp天生具有并发，就不画蛇添足了。

服务器端

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>  
#include <arpa/inet.h>
#include <string.h>
#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <unistd.h>
#include "comm.h"
/*
void FD_CLR(int fd, fd_set *set);       将fd从set清除
int  FD_ISSET(int fd, fd_set *set);     判断fd是否存在集合中
void FD_SET(int fd, fd_set *set);       将fd加入到set
void FD_ZERO(fd_set *set);              清空set
阻塞式的监控
int select(int nfds, fd_set *readfds, fd_set *writefds,
                 fd_set *exceptfds, struct timeval *timeout);
nfds:
    集合中所有fd的  最大值+1
readfds: 可读事件,表示 当前可读fd的 一个集合
    如果你想监控 某些socket/fd 的可读事件,那么 就将他们加入到该集合
    双向参数: 你在调用之前,将需要监控的所有fd都加进去
        等select返回的时候,里面只保存了 发生事件的fd
            所以, 你需要备份
writefds: 可写...................
    如果你想监控 .....................可写.................
        双向参数: 你在调用之前,将需要监控的所有fd都加进去
        等select返回的时候,里面只保存了 发生事件的fd
            所以, 你需要备份
exceptfds:异常事件,表示 fd发生异常的集合
    如果你想监控 异常事件 ............................
        双向参数: 你在调用之前,将需要监控的所有fd都加进去
            等select返回的时候,里面只保存了 发生事件的fd
                所以, 你需要备份
timeout:    指定等待的最大时间,如果在改时间内 没有 任何fd发生事件,
    返回
    struct timeval {
            long    tv_sec; 
            long    tv_usec; 
        };
    ==NULL, 永久监控
    ==非阻塞监控timeout->tv_sec=timeout->tv_usec = 0;
返回值:
    -1:  错误
    正值: 发生事件的fd的个数
    0:      超时了
*/
struct sockaddr_in serv_local;
struct sockaddr_in cli_addr;
size_t addr_sz;
int socket_serv;
int socket_client;
fd_set readfds;     //读集合
fd_set readfds_backup;      //读集合
int fd_max;
struct timeval  timeout;
int fd_client[128];
int fd_client_cnt = 0;

int serv_for_client(int socket_client)
{
    int ret;
    struct msg_type msg;
    memset(&msg,0,sizeof(msg));
    ret = recv(socket_client,&msg,sizeof(msg),0);
    if(ret <0){
        perror("recv err");
        close(socket_client);
        return -35;
    }else if(ret == 0){
        printf("server detect client over\n");
        close(socket_client);
        return -25;
    }
    printf("serv get msg:type%d tmp%d himmdy%d des: %s\n",
    msg.msg_type,ntohs(msg.tmp),ntohl(msg.himmdty),msg.des);
    msg.tmp = ntohs(msg.tmp);
    msg.himmdty = ntohl(msg.himmdty);
    msg.tmp++;      //主机字节序
    msg.himmdty += 3;
    strcpy(msg.des,"hello from serv");
    msg.tmp = htons(msg.tmp);
    msg.himmdty = htonl(msg.himmdty);
    ret = send(socket_client, &msg, sizeof(msg),0);
    if(ret <0){
        perror("send err");
        close(socket_client);
        return -36;
    } 
    return 0;
}
int main(int argc,char **argv)
{
    int ret;
    int idx;
    socket_serv = socket(AF_INET,SOCK_STREAM, 0);
    if(socket_serv <0 ){
        perror("server socket err");
        return -12;
    }
    serv_local.sin_family = AF_INET;
    serv_local.sin_port =  htons(5050);
    serv_local.sin_addr.s_addr = INADDR_ANY; /*INADDR_ANY = 0  代码自动绑定本机ip地址*/
    ret = bind(socket_serv,(struct sockaddr *)&serv_local,sizeof(serv_local));
    if(ret <0){
        perror("bind err");
        return -13;
    }
    ret = listen(socket_serv,5);
    if(ret <0){
        perror("listen err");
        return -14;
    }
    /*当前有一个socket,那么 加入到监控集合中去
    */
    FD_ZERO(&readfds);
    FD_SET(socket_serv,&readfds);
    fd_max = socket_serv;
loop:
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;
    readfds_backup = readfds;
    ret = select(fd_max+1,&readfds_backup,NULL,NULL,&timeout);
    if(ret <0){
        perror("select err");
        return -23;
    }else if(ret == 0){
        printf("select timeout, next time\n");
        goto loop;
    }
    /*readfds_backup 里面保存了发生事件的fd,遍历*/
    if(FD_ISSET(socket_serv,&readfds_backup)){  //有新的客户端发起连接
        memset(&cli_addr,0,sizeof(cli_addr));
        addr_sz = sizeof(cli_addr);
        socket_client = accept(socket_serv,(struct sockaddr *)&cli_addr,&addr_sz);
        if(socket_client < 0){
            perror("serv accept err");
            return -34;
        }
        printf("serv get client ip %s port %d\n",
            inet_ntoa(cli_addr.sin_addr) ,ntohs(cli_addr.sin_port));
        /*将新的套接字 加入监控空集合*/
        FD_SET(socket_client,&readfds);
        fd_max = fd_max > socket_client ? fd_max : socket_client;
        fd_client[fd_client_cnt++] = socket_client;
    }
    for(idx=0;idx<fd_client_cnt;idx++){
        if(FD_ISSET(fd_client[idx],&readfds_backup)){
            ret = serv_for_client(fd_client[idx]);
            if(ret <0){
                fd_client[idx] = 0;  //清空
            }
        }
    }
    goto loop;      //继续监控
    close(socket_serv);
    return 0;
}

非阻塞UDP(C语言)

服务器端

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include "comm.h"

int main(void)
{
    int flags;
    int ret;
    int serv_socket;
    struct sockaddr_in serv_addr;
    struct sockaddr cli_addr;
    socklen_t  addrlen;
    struct  msg msg;

    serv_socket = socket(AF_INET,SOCK_DGRAM, 0);
    if(serv_socket < 0 ){
        perror("udp serv socket err");
        return -34;
    }
    flags = fcntl(serv_socket,F_GETFL,0);
    flags |= O_NONBLOCK;
    fcntl(serv_socket,F_SETFL,flags);

    /*如何让 socket/fd 编程非阻塞呢
        1.读取 socket里面的 flags
            flags = fcntl(socket,F_GETFL,0);
        2.将flags对应的bit置一
            flags |= O_NONBLOCK;
        3.将flags写入socket文件内部
            fcntl(socket,F_SETFL,flags);
    */
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(3100);
    serv_addr.sin_addr.s_addr = INADDR_ANY;         //给一个0,bind发现 ip为0,则自动获取主机ip地址
    ret = bind(serv_socket,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    if(ret <0){
        perror("bind err");
        return -34;
    }
    while(1){
        /*
        非阻塞 返回值的问题
        1.正确收到数据    ret>0
        2.没有数据      ret<0   errno==EAGAIN
        3.出错            ret<0
        */
loop:
        memset(&msg,0,sizeof(msg));
        addrlen = sizeof(cli_addr);
        ret = recvfrom(serv_socket, &msg, sizeof(msg), 0,&cli_addr, &addrlen);
        if(ret < 0){
            if(errno == EAGAIN){
                printf("recv current nodata,try next\n");
                void do_something_other(void);
                sleep(1);
                goto loop;
            }

            printf("recvfrom err%d\n",ret);
            return -34;
        }
        printf("serv get msg: type%d sval%d ival%d des:%s\n",
            msg.type,msg.sval,msg.ival,msg.des);
        msg.type++;
        msg.sval++;
        ret = sendto(serv_socket,&msg,sizeof(msg),0,&cli_addr,sizeof(cli_addr));
        if(ret < 0){
            printf("sendto err%d\n",ret);
            return -34;
        }
    }
}
贪贪贪丶慎独
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
重叠IO模型
10-21
重叠IO模型是一种高效处理输入/输出（I/O）操作的机制，特别是在多任务和并发环境中。这种模型允许操作系统在进行I/O操作的同时处理其他任务，从而提高系统资源的利用率和程序的响应速度。在本文中，我们将深入探讨...
利用IO完成端口实现高性能的UDP或TCP通信
gongbenwen的专栏
09-30 1360
在重构通信层的过程中，因为需要增加连接会话处理，
第七节：IO网络通讯
impermanences的博客
09-27 307
第七节：IO网络通讯 1.网络编程：基本模型是C/S模型，两个进程间的通信 2.BIO的服务端通信模型：采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理,处理完成后，通过输出流返回应答给客户端，线程销毁。即典型的一请求一应答通宵模型。 3.BIO通信模型： 补充：《java编程思想》 Socke...
UDP.6.重叠IO模型：完成例程
老毛的博客
08-05 456
文章目录重叠IO模型：完成例程代码逻辑回调函数介绍 https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-socket 基于UDP的网络编程还有5种模型： SELECT模型 事件选择模型 异步选择模型 重叠IO模型 完成端口模型 这节讲基于UDP的重叠IO模型：完成例程。 理论部分不啰嗦了，可以看TCP的完成例程的内容 直接上逻辑及代码： 重叠IO模型：完成例程代码逻辑 和之前重叠IO模型：事件通知的服务器端代码前面部
UDP.5.重叠IO模型：事件通知
老毛的博客
08-05 1060
文章目录重叠IO模型介绍重叠IO模型：事件通知代码逻辑重叠IO模型：事件通知代码实现1.-5.io3.对客户端套接字投递WSARecvFromio4.根据需求对客户端套接字投递WSASendio3.3循环等待信号io3.3循环等待信号io3.3.1 没信号，继续等io3.3.2 有信号，先获取重叠结构上的信息（WSAGetOverlappedResult） https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sock
基于TCP或UDP的客户端与服务器编程网络聊天-课程设计（含课程报告和代码）.rar
12-28
5. **多线程/异步处理**：在网络聊天应用中，服务器通常需要处理多个并发连接，因此会涉及到多线程或多进程编程，或者使用异步IO模型来提高性能。 6. **错误处理与调试**：讨论在网络编程中可能遇到的问题，如端口...
IO 模型网络程序实验
07-19
在计算机科学领域，I/O（Input/Output）模型是处理数据传输的核心机制，...最后，通过对“IO模型网络程序实验”的深入实践，你将能够熟练地运用Winsock API进行高效的网络编程，为将来开发复杂网络应用打下坚实的基础。
socket5 服务器代理 tcp udp实现 vc++
11-03
Socket5服务器代理是一种网络通信协议，它允许客户端通过代理服务器与目标服务器进行TCP或UDP通信。在本资源中，我们讨论的是使用C++语言实现的Socket5代理服务器，这对于理解和学习网络编程，尤其是代理服务器技术...
Linux Socket编程、Linux IO模型、Linux 进程间通信完整用例
最新发布
02-16
对于系统开发者和管理员，深入理解Linux的Socket编程、IO模型以及进程间通信（IPC）是至关重要的。本资料包提供了三个主要部分的学习资源：`process_comm`涉及进程间通信，`linux_socket`涵盖Socket编程，而`io_mode...
socket网络通信（重叠I/O方式实现）包含4种方式
hill_guo的博客
05-07 687
采用重叠I/O方式实现的socket网络编程，异步非阻塞方式，代码效率比阻塞式的socket编程方式高。实现了TCP server，TCP client，UDP server，UDP client，四种方式可选，可以使用在各种场合用于监控网络数据。本程序只支持单客户端和服务端的应用场合。代码封装成库形式，非常方便移植。平台使用的是VC6.0，语言用的是C++，MFC做的界面。使用ws2_32....
5种IO模型
Good Good Sleep, Day Day Code.
03-29 134
Unix下的5种I/O模型： 1. 阻塞式I/O 2. 非阻塞式I/O 3. I/O复用（select/poll/epoll） 4. 信号驱动式（SIGIO） 5. 异步I/O（POSIX的aio_系列函数） 一个输入操作通常包括两个不同的阶段： （1）等待数据准备好 （2）从内核向进程复制数据         对于...
温湿度采集 一
贪贪贪丶慎独
07-31 2073
一，获取环境温度 SHT-30+stm32 C语言 二，上传数据 Qt C/C++ http协议 串口收发数据 三，接收数据并储存 Linux 数据库 C语言 四，数据显示 HPH HTML 反正也不多，就这些做毕业设计刚刚好，不需要全懂，了解就行。
百度鹰眼 绘制围栏
贪贪贪丶慎独
10-14 6386
一个简单的百度鹰眼demo，用来绘制地图围栏 先通过get将鹰眼服务器数据拿下来，在调用百度地图js api将围栏绘制出来如图蓝色围栏，红色围栏通过DrawingManager这个类来绘制，然后保存到服务器，围栏也可以实现编辑，删除。 当时百度好久都没有找到，就自己改了一个。
蓝牙音响DIY
贪贪贪丶慎独
08-05 5168
DIY一个蓝牙音响。 材料：两个喇叭，蓝牙解码板，双通道功放板。 效果还可以，这里分享一下，成本在四五十，某宝上都有售。
Qt 文本编辑器
贪贪贪丶慎独
10-09 1045
说起文本编辑器，我觉得VSCode真的太好用了吧。。 以前写代码都是在官方特定的继承的环境中操作，现在所有工作几乎都是在VSCode上面完成。 这里就写一个简单的多文本编辑器，确切的说是以前写的这里就发一下。
TCP三次握手、UDP协议、四种IO模型
weixin_47198561的博客
03-24 249
字节爱问TCP三次握手四次挥手UDP编程四种IO模型 TCP三次握手四次挥手 客户端先发送请求 TCP建立连接的过程 《闪电》《确认》 * 传输层向上面的应用程序提供通信服务 * 第一次握手 * client发送连接请求数据报文到server端 SYN_SENT状态 * 第二次握手 * server收到连接请求数据报文，如果同意建立连接，向client回应确认报文端 * (为TCP连接分配TCP缓存和变量) * 第三次握手 * client收到server收到确认之后，它再次向服务器端
重叠IO模型知识
佛系程序猿
04-29 955
什么是重叠IO重叠模型是一种异步IO模型。多线程结构中就考虑到采用异步的方式进行设备读写操作，即我们告诉系统对设备的读写数据，而同时应用程序的其他代码继续执行，直到获取设备操作完毕的系统通知。重叠IO的作用我们在这里做一下对使用重叠IO和非重叠IO的解释：非重叠IO的情况：在Windows中，我们通常使用CreateFile、WriteFile、ReadFile等函数对文件进行操作时，会让我们觉得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贪贪贪丶慎独

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值