TCP/UDP网络编程：网络字节序 socket() listen() bind() accept() connect() sendto() recvfrom() 线程池实现代码实例

已于 2022-02-17 14:41:45 修改
阅读量741 收藏 7
点赞数 1
分类专栏： # 网络编程 文章标签： tcp/ip linux socket 网络通信 线程池
于 2021-09-13 22:08:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33373173/article/details/120276727
版权

本文的目录导航

1 网络字节序

  • 即大小端模式。TCP/IP规定网络数据流采用大端字节序，低地址表示高字节
  • 网络字节序和主机字节序的转换：h=host, n=network, l=32位long, s=16位short
#include <arpa/inet.h>

uint32_t htonl(uint32_t hostlong);
uint32_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint32_t ntohs(uint16_t netshort);
  • sockaddr_in.sin_addr地址和字符串相互转换
#include <arpa/inet.h>

//将sockaddr_in.sin_addr地址转换成字符串
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

//将字符串转换成sockaddr_in.sin_addr地址
const char *inet_pton(int af, const char *src, void *dst);

2 socket地址的数据结构

  • socket API早于ANSI C标准化，还没有void *类型，所以需要强制类型转换struct sockaddr *类型

3 TCP socket编程

1 TCP服务器端顺序：socket() bind() listen() accept() read()/write() close()

2 TCP客户端顺序：socket() connect() read()/write() close()

3.1 socket() 返回文件描述符

  • socket()第一个形参：1）SOCK_STREAM：TCP使用的流式类型；2）SOCK_DGRM：UDP使用的无连接数据包类型
#include <sys/types.h>
#include <sys/socket.h>
//成功返回0，失败返回-1并设置errno
int socket(int domain, int type, int protocol);

3.2 sockaddr_in结构体

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
raw_socket = socket(AF_INET, SOCK_RAW, protocol);

struct sockaddr_in {
    sa_family_t sin_family; //地址类型  IPv4-AF_INET
    int_port_t sin_port; //网络字节序端口号
    struct in_addr sin_addr; //网络字节序地址
}

struct in_addr {
    uint32_t s_addr; //网络字节序地址
}

3.3 bind()

#include <sys/types.h>
#include <sys/socket.h>

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

3.4 listen()

#include <sys/types.h>
#include <sys/socket.h>

int listen(int sockfd, int backlog);

3.5 accept()

  • 服务端TCP三次握手在这里。注意此函数的套接字才是真正和客户端实际使用的套接字，之前的套接字只是建立监听而已
#include <sys/types.h>
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);

3.6 connect()

#include <sys/types.h>
#include <sys/socket.h>

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

4 TCP网络通信线程池代码实例

  • 线程池实现客户端与服务端的多线程并发通信：客户端发送标准输入到的数据给服务端，并且把服务端返回的数据显示到标准输出上；服务端把从客户端收到的数据返回给客户端，并且显示从客户端收到的数据

4.1 TCP服务端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <pthread.h>
#define err_msg(msg) {\
    perror(msg);\
    exit(1);\
}

//队列维护客户端到来的客户数量
typedef struct Task {
    int fd;
    struct Task *next;
} Task;

typedef struct Task_pool {
    Task *head, *tail;
    pthread_mutex_t lock;
    pthread_cond_t haveTask;
} Task_pool;

Task_pool *pool_init() {
    Task_pool *pool = (Task_pool *)malloc(sizeof(Task_pool));
    pool->head = NULL;
    pool->tail = NULL;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->haveTask, NULL);
    return pool;
}

//队列尾插入客户
void pool_push(Task_pool *pool, int fd) {
    pthread_mutex_lock(&pool->lock);

    Task *t = (Task *)malloc(sizeof(Task));
    t->fd = fd;
    t->next = NULL;

    if (pool->tail == NULL)
        pool->head = t, pool->tail = t;
    else
        pool->tail->next = t, pool->tail = t;

    pthread_cond_broadcast(&pool->haveTask); //条件发生，通知等待的线程去抢客户
    pthread_mutex_unlock(&pool->lock);
    return ;
}

Task pool_pop(Task_pool *pool) {
    pthread_mutex_lock(&pool->lock);

    //把锁临时释放，等待条件发生
    while (NULL == pool->head)
        pthread_cond_wait(&pool->haveTask, &pool->lock);

    Task task, *k;
    k = pool->head;
    task = *k;
    pool->head = pool->head->next;

    (pool->head == NULL) && (pool->tail = NULL);
    free(k);

    pthread_mutex_unlock(&pool->lock);
    return task;
}

void pool_free(Task_pool *pool) {
    pthread_mutex_lock(&pool->lock);

    Task *p = pool->head, *k;
    while (p) {
        k = p;
        p = p->next;
        free(k);
    }
    pool->head = NULL;

    pthread_mutex_lock(&pool->lock);
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->haveTask);
    free(pool);
    return ;
}

//第三种：创建线程池
void *pfunc(void *arg) {
    pthread_detach(pthread_self());
    char buf[100];

    Task_pool *pool = (Task_pool *)arg;

    while (true) {
        Task task = pool_pop(pool); //客户出队
        int confd = task.fd, recv = 0;
        printf("[begin] client task confd= %d\n", confd);
        while (true) {
            recv = read(confd, buf, 100);
            if (!strncmp(buf, "exit", 4))
                break;
            write(1, buf, recv);

            write(confd, buf, recv);
        }
        printf("[end] client task confd= %d\n", confd);
        close(confd);
    }

    return (void *)0;
}

/*//第二种:使用多线程实现并发服务
void *pfunc(void *arg) {
    pthread_detach(pthread_self());
    int confd = (int)(long)arg, recv;
    char buf[100];
    while (true) {
        recv = read(confd, buf, 100);
        if (!strncmp(buf, "exit", 4))
            break;
        write(1, buf, recv);

        write(confd, buf, recv);
    }

    close(confd);
    return (void *)0;
}*/

int main() {
    int listenfd, confd, recv;
    struct sockaddr_in serveraddr, clientaddr;
    socklen_t client_len;
    char buf[100], arr[INET_ADDRSTRLEN]; //INET_ADDRSTRLEN=16

    bzero(&serveraddr, sizeof(serveraddr)); //赋0值
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(8080);
    serveraddr.sin_addr.s_addr = htons(INADDR_ANY); //(u_int32_t)0x00000000

    //第三种：创建线程池
    Task_pool *pool = pool_init();
    pthread_t tid;
    for (int i = 0; i < 8; ++i) { //假设是8核CPU
        pthread_create(&tid, NULL, pfunc, (void *)pool);
        printf("thread is: %#lx\n", tid);
    }

    //服务端第一步创建socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0)
        err_msg("socket");
    //第二步绑定
    if (bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
        err_msg("bind");
    //第三步监听
    if (listen(listenfd, 2) < 0) //客户端排队队列最多有2个
        err_msg("listen");
    //第四步accept
    printf("Accepting!\n");
    while (true) {
        client_len = sizeof(clientaddr);
        confd = accept(listenfd, (struct sockaddr *)&clientaddr, &client_len);
        if (confd < 0)
            err_msg("accept");
        printf("recv client ip: %s, port:%d\n", inet_ntop(AF_INET, &clientaddr.sin_addr, arr, sizeof(arr)), ntohs(clientaddr.sin_port));

        pool_push(pool, confd); //客户入队

        /* //第一种:使用多进程实现并发服务
        pid_t pid = fork();
        if (pid < 0)
            err_msg("fork");
        if (pid > 0) {
            close(confd);
            while(waitpid(-1, NULL, WNOHANG));
            continue;
        }
        close(listenfd);

        while (true) {
            recv = read(confd, buf, 100);
            if (!strncmp(buf, "exit", 4))
                break;
            write(1, buf, recv);

            write(confd, buf, recv);
        }

        //第二种:使用多线程实现并发服务
        pthread_t tid;
        pthread_create(&tid, NULL, pfunc, (void *)confd);
        printf("thread is: %#lx\n", tid);

        close(confd);*/
    }

    pool_free(pool);
    return 0;
}

4.1.1 Linux TCP服务端：epoll+多线程web服务器

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/epoll.h>
#define LEN 10000
#define err_msg(msg) {\
    perror(msg);\
    exit(1);\
}

//队列维护客户端到来的客户数量
typedef struct Task {
    int fd;
    struct Task *next;
} Task;

typedef struct Task_pool {
    Task *head, *tail;
    pthread_mutex_t lock;
    pthread_cond_t haveTask;
} Task_pool;

Task_pool *pool_init() {
    Task_pool *pool = (Task_pool *)malloc(sizeof(Task_pool));
    pool->head = NULL;
    pool->tail = NULL;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->haveTask, NULL);
    return pool;
}

//队列尾插入客户
void pool_push(Task_pool *pool, int fd) {
    pthread_mutex_lock(&pool->lock);

    Task *t = (Task *)malloc(sizeof(Task));
    t->fd = fd;
    t->next = NULL;

    if (pool->tail == NULL)
        pool->head = t, pool->tail = t;
    else
        pool->tail->next = t, pool->tail = t;

    pthread_cond_broadcast(&pool->haveTask); //条件发生，通知等待的线程去抢客户
    pthread_mutex_unlock(&pool->lock);
    return ;
}

Task pool_pop(Task_pool *pool) {
    pthread_mutex_lock(&pool->lock);

    //把锁临时释放，等待条件发生
    while (NULL == pool->head)
        pthread_cond_wait(&pool->haveTask, &pool->lock);

    Task task, *k;
    k = pool->head;
    task = *k;
    pool->head = pool->head->next;

    (pool->head == NULL) && (pool->tail = NULL);
    free(k);

    pthread_mutex_unlock(&pool->lock);
    return task;
}

void pool_free(Task_pool *pool) {
    pthread_mutex_lock(&pool->lock);

    Task *p = pool->head, *k;
    while (p) {
        k = p;
        p = p->next;
        free(k);
    }
    pool->head = NULL;

    pthread_mutex_lock(&pool->lock);
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->haveTask);
    free(pool);
    return ;
}

//第四种：epoll+线程池
void *pfunc(void *arg) {
    pthread_detach(pthread_self());
    char buf[LEN];

    Task_pool *pool = (Task_pool *)arg;

    if (true) {
        Task task = pool_pop(pool); //客户出队
        int confd = task.fd, recv = 0;
        printf("[begin] client task confd= %d\n", confd);
        while (true) {
            recv = read(confd, buf, LEN);
            write(1, buf, recv);

            char respond[100] = {"HTTP/1.1 200 OK\r\nContent-Type:text/html\r\n\r\n<html><body>Hello world!<H3><H3></body></html>"};
            write(confd, respond, strlen(respond));
        }
        printf("[end] client task confd= %d\n", confd);
        if (!strncmp(buf, "exit", 4))
            close(confd);
    }

    return (void *)0;
}

int main() {
    int listenfd, confd, recv;
    struct sockaddr_in serveraddr, clientaddr;
    socklen_t client_len;
    char buf[LEN], arr[INET_ADDRSTRLEN]; //INET_ADDRSTRLEN=16

    bzero(&serveraddr, sizeof(serveraddr)); //赋0值
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(8080);
    serveraddr.sin_addr.s_addr = htons(INADDR_ANY); //(u_int32_t)0x00000000

    //第三种：创建线程池
    Task_pool *pool = pool_init();
    pthread_t tid;
    for (int i = 0; i < 8; ++i) { //假设是8核CPU
        pthread_create(&tid, NULL, pfunc, (void *)pool);
        printf("thread is: %#lx\n", tid);
    }

    //服务端第一步创建socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0)
        err_msg("socket");

    //第四种：epoll实现IO复用
    int epfd = epoll_create(128);
    struct epoll_event ev, events[128];
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = listenfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    //第二步绑定
    if (bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
        err_msg("bind");
    //第三步监听
    if (listen(listenfd, 2) < 0) //客户端排队队列最多有2个
        err_msg("listen");
    //第四步accept
    printf("Accepting!\n");
    while (true) {
        int nfds = epoll_wait(epfd, events, 128, -1); //-1表示阻塞等待事件到来
        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == listenfd) {
                client_len = sizeof(clientaddr);
                confd = accept(listenfd, (struct sockaddr *)&clientaddr, &client_len);
                if (confd < 0)
                    err_msg("accept");
                printf("recv client ip: %s, port:%d\n", inet_ntop(AF_INET, &clientaddr.sin_addr, arr, sizeof(arr)), ntohs(clientaddr.sin_port));

                //监听事件
                ev.events = EPOLLIN | EPOLLET; //事件到来或边缘触发
                ev.data.fd = confd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, confd, &ev);
            } else if (events[i].events & EPOLLIN) { //发生事件：有数据到来
                int clifd = events[i].data.fd;
                if (clifd < 3) continue;
                pool_push(pool, clifd); //客户入队*/
            }
        }
    }

    pool_free(pool);
    return 0;
}

4.2 TCP客户端

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

int main() {
    char buf[100] = {"Hello!"};

    struct sockaddr_in serveraddr;
    bzero(&serveraddr, sizeof(serveraddr)); //赋0值
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &serveraddr.sin_addr);

    int sock = socket(AF_INET, SOCK_STREAM, 0);

    connect(sock, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    int recv;
    while (recv = read(0, buf, 100)) {     
        write(sock, buf, recv);
        if (!strncmp(buf, "exit", 4))
            break;
        recv = read(sock, buf, 100);
        printf("recv server:\n");
        write(1, buf, recv);
    }

    close(sock);

    return 0;
}

5 UDP socket编程

服务端顺序：socket() bind() recvfrom() sendto() close()

客户端顺序：socket() sendto() recvfrom() close()

5.1 sendto() recvfrom()

#include <sys/types.h>
#include <sys/socket.h>

//发送数据
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

//接收数据
ssize_t recvfrom(int sock, void *buf, size_t len, int flags,
     struct sockaddr *from, socklen_t *fromlen);

  • sendto()的函数形参：

    sockfd：socket描述符

    buf：UDP数据报缓存区

    len：UDP数据报的长度

    flags：调用方式标志位（一般为0）

    dest_addr：接收方目标主机的结构体地址

    addrlen：dest_addr结构体的长度，一般为16

6 UDP网络通信代码示例

6.1 UDP服务端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#define err_msg(msg) {\
    perror(msg);\
    exit(1);\
}

int main() {
    char buf[100], arr[INET_ADDRSTRLEN]; //INET_ADDRSTRLEN=16
    socklen_t client_len;
    struct sockaddr_in server, client;
    bzero(&server, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = htonl(INADDR_ANY);
    server.sin_port = htons(8080);

    int sock, recv;
    sock = socket(AF_INET, SOCK_DGRAM, 0);

    bind(sock, (struct sockaddr *)&server, sizeof(server));

    printf("updserver already\n");

    while (true) {
        //阻塞等待客户端数据请求
        recv = recvfrom(sock, buf, 100, 0, (struct sockaddr *)&client, &client_len);
        if (recv < 0)
            err_msg("recvfrom");
        printf("recvfrom client ip:%s, port:%d\n", inet_ntop(AF_INET, &client.sin_addr, arr, sizeof(arr)), ntohs(client.sin_port));
	
        //发送数据给客户端
        sendto(sock, buf, recv, 0, (struct sockaddr *)&client, sizeof(client));
    }

    close(sock);
    return 0;
}

6.2 UDP客户端

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

int main() {
    char buf[100];
    struct sockaddr_in server;
    bzero(&server, sizeof(server));
    server.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &server.sin_addr);
    server.sin_port = htons(8080);

    int sock, recv;
    sock = socket(AF_INET, SOCK_DGRAM, 0);

    while (recv = read(0, buf, 100)) {
        //发送数据给服务端
        recv = sendto(sock, buf, recv, 0, (struct sockaddr *)&server, sizeof(server));
	
        //阻塞等待服务端应答的数据
        recv = recvfrom(sock, buf ,100, 0, NULL, 0);
        write(1, buf, recv);
    }

    close(sock);
    return 0;
}
-兮
关注
专栏目录
Linux网络编程 | socket介绍、网络字节序与主机字节序概念与两者的转换、TCP/UDP 连接中常用的 socket 接口
Jormungand_V的博客
08-20 547
文章目录套接字sockaddr 和 sockaddr_in 套接字 为什么要用到套接字？ 我们知道，数据链路层、网络层、传输层协议是在内核中实现的。而 socket 就是 操作系统 提供给 应用程序 通过 系统调用 访问这些 协议服务 的一组 API 。socket 不但可以访问内核中 TCP/IP 协议栈，而且访问其他网络协议栈。 socket 定义的 API 提供哪些功能？ 将 应用程序数据 从 用户缓冲区 中复制到 TCP/UDP 内核发送缓冲区 ，将发送数据交付内核。 从 TCP/UDP
Python 网络编程 TCP/UDP 详细基础
weixin_55643605的博客
10-05 4421
1 基础概念 1.1 Linux Windows 命令行查看网络信息 Linux: ifconfig windows: ipconfig 开/关网卡：sudo ifconfig ###(网卡名) up/down 1.2 IP地址 IP地址（Internet Protocol Address）是指互联网协议地址，又译为网际协议地址。 IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。 IP地址即在网络中标识一台.
socket UDP、TCP发送接收数据
weixin_43973956的博客
02-02 2740
socket UDP、TCP发送接收数据基础计算机网络概念两台电脑的通信IP地址与协议公网IP和内网IPNAT技术端口介绍socket简介TCP/IP协议socketUDP发送接收数据udp发送数据udp接收数据TCP发送接收数据TCP与UDP的区别 基础计算机网络概念 两台电脑的通信 两台电脑之间的通信类似于写信，数据通过网线传输到服务器，在经过服务器传输给目标电脑，其中ip地址是唯一标识，用来识别你要发送的对象，在写信中ip地址就相当于我们的通信地址。 IP地址与协议 规定网络地址的协议称为ip协
udp server的connect和listen
u010643777的专栏
09-22 3895
 之前，学习tcp的时候，学习了epoll，主要应用于大连接IO事件的管理。能否将epoll和udp结合，也能管理大量的socket描述符呢？当时，查了点资料，就写了一篇博客[1]。udp是面向无连接的，在服务端，每当一个客户端数据包到来时，数据包中携带的ip和port，使得来自不同客户端的数据包是可以区分的。但是epoll是是对大量fd的管理，在新的请求到来时，就可以创建一个新的fd，用来标志一...
Socket网络字节序—简单易懂
Jacksqh的博客
07-30 1712
网络字节序 在计算机的世界中有两种字节序 大端字节序：高地址存低位，低地址存高位 小端字节序：低地址存低位，高地址存高位 比如我们的端口号就是用16位来存储两个字节，比如端口号为1001用16进制表示为0x03 e9 网络数据流同样有大端小端之分，那么如何定义网络数据流的地址呢？发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出，接收主机把从网络上接到的字节依次保存在接收缓冲区中，也是按内存地址从低到高的顺序保存，因此，网络数据流的地址应这样规定：先发出的数据是低地址，后发出的数据
connect函数和accept函数哪个先返回？ 客户端和服务端哪个先完成建立tcp连接？
认知 行动 坚持
07-01 9735
connect函数和accept函数哪个先返回？ 客户端和服务端哪个先完成建立tcp连接？ 这是个有趣的问题， 需要对socket编程和TCP三次握手有所了解。        从三次握手的过程来看， 当然是connect函数先返回啦。        connect正常返回后， 客户端认为建立了TCP连接， accept函数正常返回后， 服务端认为建立了TCP连接。
tcp udp协议里使用bind函数的理解
jacycle的专栏
02-08 2938
#define SERVICE_IPADDR  "192.168.1.12" #define SERVER_PORT      30000 struct sockaddr_in server_addr; int tolen; int server_fd = -1; if((server_fd = socket(AF_INET, SOCK_DGRAM, 0)) >=
Linux 网络编程 TCP/UDP编程
人生一世 草木一秋
08-17 1517
在TCP/IP协议族中，有很多种协议。TCP/IP协议群中的核心协议被设计运行在网络层和传输层，它们为网络中的各主机提供通信服务，也为模型的最高层--应用层中的协议提供服务。其中的TCP和UDP协议就是应用在传输层的协议。...
TCP/UDP编程 & socket常用接口说明
r21nn的博客
01-08 1686
TCP/UDP编程接口说明，TCP/UDP编程流程理解，TCP/UDP编程实例。
【python】网络编程socket TCP UDP
最新发布
weixin_38009144的博客
03-28 1112
互联网协议族 即通用标准协议，任何私有网络只要支持这个协议，就可以接入互联网。
UDP
没长正
08-10 381
代码示例使用 UdpClient 侦听发送到端口 11,000 上的定向的广播地址 192.168.1.255 的 UDP 数据文报。客户端接收消息字符串并将消息写入控制台。  using System;   using System.Net;   using System.Net.Sockets;   using System.Text;      public class UDPLi
使用UDP如何进行网络通信
hei我在这
06-20 1万+
UDP是一种面向无连接的通信协议，何为面向无连接？即两方通信时，另一方可以不在线，但是一方却可以发送消息，期间消息段可能会丢失，但是因为是面向无连接，所以不保证消息一定能送达。 UDP是面向数据报的。但是在通信时，无法保证对方机器和我们的机器的字节序端口什么的都一样，比如有的机器是大端，有的机器是小端，那么报文传输到对方的机器时就会变成混乱的无序的。由于该项问题的产生，所以在网络中对报文进行了规...
网络编程 基础概念（TCP和UDP，端口，字节序）
weixin_48651223的博客
08-04 572
网络编程
TCP/UDP服务器listen与recvfromd函数的顺序所致的问题
此号停用
07-19 849
服务端写了两个套接字，分别接收udp和tcp listen若写在recvfrom之前，服务端只能收到udp，而客户端会提示connect错误 于是检查了accept函数，并没有发现问题 将listen放在recvfrom之前就解决了，原因未明 代码如下： 客户端
socket里sendto()函数
热门推荐
radissh的博客
08-01 1万+
函数原型： int sendto ( socket s , const void * msg, int len, unsigned int flags, const struct sockaddr * to , int tolen ) ; 头文件：#include <sys/types.h> / #include <sys/socket.h> sendto() 用来将数据...
UDP的epoll并发框架-UDP Listener解决OpenUOM的并发问题
Netfilter
07-05 1万+
UDP具有是一种很好的封装协议，比如OpenVPN使用UDP封装会比TCP好很多，现在越来越多的业务采用UDP传输，然后自己定义按序到达以及流控逻辑，然而就我个人的使用经验来看，UDP太难做并发，大多数情况下，使用UDP会让epoll等高性能event机制优势全无。本文以OpenVPN为例，说明一下我是怎么解决UDP并发问题的。异步并发模型与epoll和apache相比，nginx采用异步的处理方
Linux Socket---write/send/sendto/wirev/sendmsg
迷失的专栏
10-18 1490
首先，我们从一个实际的数据包发送的例子入手，来看看其发送的具体流程，以及过程中涉及到的相关数据结构；在我们的虚拟机上发送icmp回显请求包，ping另一台主机192.168.1.111。我们使用系统调用sendto发送这个icmp包。 ssize_t sendto(int s, const void *buf, size_t len, int flags, ...
c# socket接收字符串_udp网络程序-发送、接收数据
weixin_39704374的博客
11-29 483
1. udp网络程序-发送数据创建一个基于udp的网络程序流程很简单，具体步骤如下：创建客户端套接字发送/接收数据关闭套接字代码如下：#coding=utf-8from socket import *# 1. 创建udp套接字udp_socket = socket(AF_INET, SOCK_DGRAM)# 2. 准备接收方的地址# '192.168.1.103'表示目的ip地址# 8080表示目...
网络编程--Socket编程（UDP）
junaozun的博客
05-23 524
TCP和UDP对比优缺点： TCP通信：面向连接的，可靠的数据包传输。 UDP通信：无连接的，不可靠的报文传递。 UDP通信的优点：由于无需建立连接就可以传递数据，所以传输速度远远比TCP通信快。 UDP通信的缺点：无连接，因此会丢包严重。需要在应用层封装一个协议校验传输层UDP协议的传递数据。 例如QQ，微信都是用的UDP传输协议。 TCP和UDP差异对照表： 使用场景： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值