摘要：
本文将讨论UDP的并发实现机制。给出了两种实现方法。第一种是最为常见的，TFTP传输的方式。
第二种是对UDP进一步封装，以达到并发的可能。主要是采用队列、多线程的方法。后面会给出一个简单的实现例子，以供大家参考。功能方面较为简单，以后会慢慢完善。
现将思路整理如下，有兴趣的同学可以一起讨论。代码稍后公布。
众所周知，通常所见的的TCP服务器都是并发实现的，即服务同时处理多个请求，
而不是等待前一个完成再处理下一个请求，这个实现得益于TCP的listen()与connect()的分工处理机制。
而对于 UDP 没有这种监听和连接机制，所以它必须等待前一处理完成才能继续处理下一个客户的请求。
但并不是说UDP实现并发服务器是不可能的，只是与上面的实现稍有不同。
123456UDP服务器并发的两种方法：
一、比较常用的处理方法是：
服务器（知名端口）等待一下客户的到来，当一个客户到来后，记下其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);
}
}