linux UDP并发服务器

摘要：
本文将讨论UDP的并发实现机制。给出了两种实现方法。第一种是最为常见的，TFTP传输的方式。
第二种是对UDP进一步封装，以达到并发的可能。主要是采用队列、多线程的方法。后面会给出一个简单的实现例子，以供大家参考。功能方面较为简单，以后会慢慢完善。
现将思路整理如下，有兴趣的同学可以一起讨论。代码稍后公布。

    众所周知，通常所见的的TCP服务器都是并发实现的，即服务同时处理多个请求，
而不是等待前一个完成再处理下一个请求，这个实现得益于TCP的listen()与connect()的分工处理机制。

而对于 UDP 没有这种监听和连接机制，所以它必须等待前一处理完成才能继续处理下一个客户的请求。
但并不是说UDP实现并发服务器是不可能的，只是与上面的实现稍有不同。
123456

UDP服务器并发的两种方法：
一、比较常用的处理方法是：
服务器（知名端口）等待一下客户的到来，当一个客户到来后，记下其IP和port，然后同理，
服务器fork一个子进程，建立一个socket再bind一个随机端口，然后建立与客户的连接，
并处理该客户的请求。父进程继续循环，等待下一个客户的到来。在tftpd中就是使用这种技术的。

    大概的实现如下:

        for ( ; ; )
        {
           /* 等待新的客户端连接 */
            recvform( &from_addr)

            /* 创建一个新的进程，由该进程去处理 */
           if (fork() == 0)
                break; //子进程跳出循环   
        }

        //child now here
        peer = socket(AF_INET, SOCK_DGRAM, 0);
        //绑定一个随机端口
        myaddr.sin_port = htons(0); 
        bind(peer,(struct sockaddr *)&myaddr, / 
                                        sizeof myaddr)
        /* 
            把这个套接字跟客户端的地址连接起来
            这也就意味之后之后套接字使用 send recv这些函数时
            都是直接跟指定的客户端进行通信的
        */
        connect(peer, (struct sockaddr *)&from, sizeof from)

以上方式简单实用，但是每来个客户端都需要创建一个新的 socket，为每个客户端分配一个新的临时端口，然后客户端，之后的通信需要跟新的端口进行数据传输。
二、如果对上述不满意。我们可以采用新的策略。对UDP进行封装，以此实现类型TCP的功能。 我们来看下一个简单 TCP 服务器的原型：

        int main()
        {
            /* 初始化socket套接字 */
            sockfd = init_socket(); 
            /* 开始监听 */
            if(listen(sock_fd, BACKLOG) == -1)
            {
                perror("listen is error\r\n");
                exit(1);
            }
            while(1)
            {
                /* 等待新的客户端连接 */
                if((new_fd = accept(sock_fd, (struct sockaddr *)&their_addr, &sin_size)) == -1)
                {
                    perror("accept");
                    continue;
                }
                /* fork出一个进程，由该进程去处理这个连接 */
                if(!fork())
                {
                }
            }
        }     

    我们封装出几个跟上面的TCP相似的函数接口。使用这些接口，可以很简单写出一个UDP并发服务器。例如：

        /* 主函数 */
        int main(int argc, char *argv[])
        {
            /* 定义一个listen指针。该结构体是自己定义的 */
            struct listen *_listen;
            /* 初始化socket，这个初始化过程跟普通的UDP初始化 socket套接字一样 */
            sockfd = init_socket(); 

            /*
                开始监听这个socket. 最大的连接数为10，也就是说最多只有10个客户端
                封装好的一个函数，功能有点类似于 TCP协议中的 listen 函数
            */
            server_listen(&sockfd, 10);

            while(1)
            {
                /* 
                获得一个连接。类似于TCP的 accept 函数 
                需要注意的是，如果没有连接， server_accept 函数将进入休眠状态，直到有一个新的客户端数据
                客户端只有在第一次发生数据过来的时候，才会创建一个新的 listen ，并唤醒 server_accept 函数
                之后，这个客户端的所有数据都将发送到 这个新的 listen 的数据队列中。
                所以。通过这个 listen ，我们可以创建一个进程，由该进程去处理这个客户端之后的请求
                这里，listen 有点像 TCP 协议中的 accept 函数新建的 sockfd
                */
                _listen = server_accept();

                /* 
                虽然说 server_accept 会进入休眠，但是仍然会被其它信号唤醒，所以要做个判断
                判断下是否为 NULL 。为 NULL 则说明没有新的连接 
                */
                if(_listen == NULL){
                    continue;
                }

                printf("new client \r\n");
                /* 
                启动一个 listen_phread 线程，并且，由该线程去处理这个连接
                类似于TCP 的fork
                */
                listen_pthread(_listen, listen_phread);
            }
        }

    listen_phread 线程简单实现：
12

        void *listen_phread(void *pdata)
        {
            int ret;
            char buf[1204];
            struct sockaddr_in clientaddr;

            /* 获得 listen */
            struct listen *_listen;
            _listen = (struct listen *)pdata;

            while(1)
            {
                /*
                recv_from_listen 也是一个封装好的函数，功能是从这个 lsiten 中获取数据
                最后一个参数表示无数据时休眠的时间
                -1 表示永久休眠。知道有数据为止
                */
                ret = recv_from_listen(_listen, &clientaddr, buf, 1204, -1);
                if(ret == -1)
                {
                    printf("%p recv is err \r\n", _listen);
                }else{
                    printf("%p recv %d byte data is [%s]\r\n", _listen, ret, buf);
                    if((ret = sendto(sockfd, buf, ret, 0, (struct sockaddr *)(&(_listen->addr)), 
                                            sizeof(struct sockaddr))) == -1)
                    {
                        perror("sendto :");
                    }
                    printf("sento [%s]\r\n", buf);
                }
            }
            /* 关闭连接，会释放内存，注意，一个listen 被创建后，需要使用这个函数释放内存 */
            listen_close(_listen);
        }

    lsiten 结构体原型：
12
        struct listen{      
            struct sockaddr addr;       /* 数据包地址信息 */
            int data_num;               /* 数据包数量 */

            int list_flg;               /* 是否已经被监听了 */

            pthread_mutex_t mutex;  /* 线程锁 */

            /* 这两个条件变量相关的 */

            pthread_mutex_t recv_mtx;
            pthread_cond_t recv_cond;

            struct list_head head;      /* 数据包队列 */

            struct list_head listen_list;       /*接收的线程队列 */
        };
实现原理：
    这个接口函数是基于队列、多线程实现的。这里简单地说下原理，稍后有时间我会对代码进一步分析


1.  listen 队列：
    系统会创建一个队列，该队列的成员为一个 listen ，每个 listen 的 addr 元素会记录下自己要接收的
    客户端。
    之后，server_listen 创建一个线程，由该线程去接收数据。
    接收到网络数据后，会遍历 listen 链表，找到一个想要接收这个数据的 listen 。
    如果没有，会创建一个新的 listen ，并将这个 listen 加入到 listen 队列中去

2   数据包队列
    找到 listen 后，每个 listen 其实就是一个 数据包队列头。系统会把数据放到 这个 listen 数据包队列中去
    然后唤醒 recv_from_listen 

也就是说，系统的队列结构如下

listen 队列
    listen(1) -> listen(2) -> listen(3) -> listen(4) -> .......
        |           |           |
      data(1)     data         data
        |           |
      data(1)     data

每个listen本身就是一个数据包队列头


recv_from_listen 函数会试图去从一个 listen 的数据包队列中获取数据，如果没有数据，则进入休眠状态。

主要函数接口：

void listen_head_init(struct list_head *head)
初始化一个 链表头

int listen_add(struct list_head *head, listen_t *listen)
将要监听的 listen 添加到这个链表头

recv_from_listen_head
从链表中获取数据

示例：

    //我们创建两个 listen_head 
    struct list_head poll_head_1, poll_head_2;

    int main(int argc, char *argv[])
    {
        int poll_num = 0;
        struct listen *_listen;

        /* 初始化socket */
        sockfd = init_socket(); 

        /*
            开始监听这个socket. 运行最大的连接数为10
            该函数类似于TCP协议中的 int listen(SOCKET sockfd, int backlog)
        */
        server_listen(&sockfd, 10);

        /* 初始化这个poll 机制 */
        listen_head_init(&poll_head_1);
        listen_head_init(&poll_head_2);

        while(1)
        {
            /* 获得一个连接。类似于TCP的
            int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 
            */
            _listen = server_accept();

            if(_listen == NULL){
                continue;
            }

            printf("new client \r\n");

            if(poll_num < 5)
            {
                /* 前面五个连接者添加到 poll_head_1 */
                poll_num ++;
                listen_add(&poll_head_1, _listen);
            }else{
                /* 添加到 poll_head_2 */
                poll_num ++;
                listen_add(&poll_head_2, _listen);
            }
        }
    }
​```
 然后我们就可以从中两个 listen_head 中读取数据了
​```
    while(1)
    {
        /*
        从 poll_head_1 中读取数据。
        此时，前面五个 listen 被挂钩到这个 poll_head_1，所以这五个listen中任何一个有了数据
        recv_from_listen_head 都会返回，而且将 _listen 指向这个 listen 
        这样，我们就可以知道是哪个listen有数据了
        */
        ret = recv_from_listen_head(poll_head_1, &_listen, (struct sockaddr *)&clientaddr, buf, 1204, -1);
        if(ret == -1)
        {
            printf("%p recv is err \r\n", _listen);
        }else{
            printf("__ poll %p recv %d byte data is [%s]\r\n", _listen, ret, buf);
            if((ret = sendto(sockfd, buf, ret, 0, (struct sockaddr *)(&(_listen->addr)), 
                                    sizeof(struct sockaddr))) == -1)
            {
                perror("sendto :");
            }
            printf("sento [%s]\r\n", buf);
        }
    }