基带信号就是将数字信号1或0直接用两种不同的电压来表示，然后送到线路上去传输。
  
宽带信号则是将基带信号进行调制后形成的频分复用模拟信号。
  
多路复用技术的基本原理是：各路信号在进入同一个有线的或无线的传输媒质之前，先采用调制技术把它们调制为互相不会混淆的已调制信号，然后进入传输媒质传送到对方，在对方再用解调（反调制）技术对这些信号加以区分，并使它们恢复成原来的信号，从而达到多路复用的目的。
  
常用的多路复用技术有频分多路复用技术和时分多路复用技术。
  
频分多路复用是将各路信号分别调制到不同的频段进行传输，多用于模拟通信。频分复用(FDM，Frequency Division Multiplexing)就是将用于传输信道的总带宽划分成若干个子频带(或称子信道)，每一个子信道传输1路信号。频分复用要求总频率宽度大于各个子 信道频率之和，同时为了保证各子信道中所传输的信号互不干扰，应在各子信道之间设立隔离带，这样就保证了各路信号互不干扰(条件之一)。频分复用技术的特 点是所有子信道传输的信号以并行的方式工作，每一路信号传输时可不考虑传输时延，因而频分复用技术取得了非常广泛的应用。频分复用技术除传统意义上的频分复用(FDM)外，还有一种是正交频分复用(OFDM)。频分多路复用的原理图如下所示：
  
  
时分多路复用技术是利用时间上离散的脉冲组成相互不重叠的多路信号，广泛应用于数字通信。时分多路复用适用于数字信号的传输。由于信道的位传输率超过每一路信号的数据传输率,因此可将信道按时间分成若干片段轮换地给多个信号使用。每一时间片由 复用的一个信号单独占用,在规定的时间内,多个数字信号都可按要求传输到达,从而也实现了一条物理信道上传输多个数字信号。假设每个输入的数据比特率是 9. 6kbit / s ,线路的最大比特率为76. 8 kbit / s ,则可传输8 路信号。
  
除了频分和时分多路复用技术外，还有一种波分复用技术。这是在光波频率范围内，把不同波长的光波，按一定间隔排列在一根光纤中传送。这种用于光纤通信的“波分复用”技术，现在正在迅速发展之中。波分复用(WND)是将两种或多种不同波长的光载波信号(携带各种信息)在发送端经复用器(亦称合波器，Multiplexer)汇合在一起，并耦合到光线路的同一根光纤中进行传输的技术；在接收端，经解复用器(亦称分波器或称去复用器，Demultiplexer)将各种波长的光载波分离，然后由光接收 机作进一步处理以恢复原信号。这种在同一根光纤中同时传输两个或众多不同波长光信号的技术，称为波分复用
  
频分多路复用与时分多路复用的区别如下：     
  (1)微观上，频分多路复用的各路信号是并行的，而时分多路复用是串行的。
  
  (2)频分多路复用较适合于模拟信号，而时分多路复用较适用于数字信号。
  
频分多路复用是将传输介质的可用带宽分割成一个个“频段”，以便每个输入装置都分配到一个“频段”。传输介质容许传输的最大带宽构成一个信道，因此每个“频段”就是一个子信道。
  
频分多路复用的特点是：每个用户终端的数据通过专门分配给它的信道传输，在用户没有数据传输时，别的用户也不能使用。频分多路复用适合于模拟信号的频分传输，主要用于电话和电缆电视(CATV)系统，在数据通信系统中应和调制解调技术结合使用。
  

http://blog.csdn.net/seekerzhou/article/details/8146616

1. 绪论
        本文对linux下几种常用的多路复用模型进行总结，不涉及其他操作系统如freeBSD等的多路复用技术。
2. 多路复用模型介绍

       一般地，I/O多路复用机制都依赖于一个事件多路分离器(Event Demultiplexer)。分离器对象可将来自事件源的I/O事件分离出来，并分发到对应的read/write事件处理器(Event Handler)。开发人员预先注册需要处理的事件及其事件处理器（或回调函数）；事件分离器负责将请求事件传递给事件处理器。两个与事件分离器有关的模式是Reactor和Proactor。Reactor模式采用同步IO，而Proactor采用异步IO。
3. 常用的多路复用模型
3.1 select
1) 相关API



[cpp] 
view plaincopyprint?

int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);  
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

对fd_set的一些操作宏：



[cpp] 
view plaincopyprint?

FD_ZERO(fd_set *set) - clears a file descriptor set   
FD_SET(int fd, fd_set *set) - adds fd to the set   
FD_CLR(int fd, fd_set *set) - removes fd from the set   
FD_ISSET(int fd, fd_set *set) - tests to see if fd is in the set   
FD_ZERO(fd_set *set) - clears a file descriptor set 
FD_SET(int fd, fd_set *set) - adds fd to the set 
FD_CLR(int fd, fd_set *set) - removes fd from the set 
FD_ISSET(int fd, fd_set *set) - tests to see if fd is in the set 


2) select机制的原理介绍
理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。
（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。 
（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1) 
（3）若再加入fd＝2，fd=1,则set变为0001,0011 
（4）执行select(6,&set,0,0,0)阻塞等待 
（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。 
 
3） select服务器伪码：



[cpp] 
view plaincopyprint?

array[slect_len]; nSock=0; array[nSock++]=listen_fd; maxfd=listen_fd;   
while {   
   FD_ZERO(&set);   
   foreach (fd in array)  {   
       fd大于maxfd，则maxfd=fd   
       FD_SET(fd,&set)   
   }   
   res=select(maxfd+1,&set,0,0,0)；   
   if(FD_ISSET(listen_fd,&set)) {   
       newfd=accept(listen_fd);   
       array[nsock++]=newfd;   
       if(--res<=0) continue   
   }   
   foreach 下标1开始 (fd in array)  {   
       if(FD_ISSET(fd,&set))   
           执行读等相关操作，如果错误或者关闭，则要删除该fd，将array中相应位置和最后一个元素互换就好，nsock减一   
           if(--res<=0) continue   
   }   
}  
array[slect_len]; nSock=0; array[nSock++]=listen_fd; maxfd=listen_fd; 
while { 
   FD_ZERO(&set); 
   foreach (fd in array)  { 
       fd大于maxfd，则maxfd=fd 
       FD_SET(fd,&set) 
   } 
   res=select(maxfd+1,&set,0,0,0)； 
   if(FD_ISSET(listen_fd,&set)) { 
       newfd=accept(listen_fd); 
       array[nsock++]=newfd; 
       if(--res<=0) continue 
   } 
   foreach 下标1开始 (fd in array)  { 
       if(FD_ISSET(fd,&set)) 
           执行读等相关操作，如果错误或者关闭，则要删除该fd，将array中相应位置和最后一个元素互换就好，nsock减一 
           if(--res<=0) continue 
   } 
}


4）select的特点：

•可监控的fd个数取决与sizeof(fd_set)的值，同是还会受限于内核的设置，系统默认支持1024，可以通过命令修改，但治标不治本。 
•select每次只返回有事件的fd，没有事件的fd被清空，需另保存所有注册的fd，在每次select调用前清理fd_set，重新注册，同时取出最大的fd+1作为每一个参数。
•需要遍历所有注册的fd判断是否有事件发生


3.2 poll
1） 相关API



[cpp] 
view plaincopyprint?

int poll(struct pollfd *ufds, unsigned int nfds, int timeout);  
int poll(struct pollfd *ufds, unsigned int nfds, int timeout);


其中struct pollfd的定义如下：


[cpp] 
view plaincopyprint?

struct pollfd {  
　　int fd;           /* file descriptor */  
　　short events;     /* requested events */  
　　short revents;    /* returned events */  
 };  
struct pollfd {
　　int fd;           /* file descriptor */
　　short events;     /* requested events */
　　short revents;    /* returned events */
 };



2） poll实现的服务器伪代码：



[cpp] 
view plaincopyprint?

struct pollfd fds[POLL_LEN];  
unsigned int nfds=0;  
fds[0].fd=server_sockfd;  
fds[0].events=POLLIN|POLLPRI;  
nfds++;  
while {  
    res=poll(fds,nfds,-1);  
    if(fds[0].revents&(POLLIN|POLLPRI)) {  
        执行accept并加入fds中，nfds++  
        if(--res<=0) continue  
    }  
    循环之后的fds，if(fds[i].revents&(POLLIN|POLLERR )) {  
        读操作或处理异常等  
                 if(--res<=0) continue  
    }  
}  
struct pollfd fds[POLL_LEN];
unsigned int nfds=0;
fds[0].fd=server_sockfd;
fds[0].events=POLLIN|POLLPRI;
nfds++;
while {
	res=poll(fds,nfds,-1);
	if(fds[0].revents&(POLLIN|POLLPRI)) {
	    执行accept并加入fds中，nfds++
	    if(--res<=0) continue
	}
	循环之后的fds，if(fds[i].revents&(POLLIN|POLLERR )) {
	    读操作或处理异常等
         	     if(--res<=0) continue
	}
}
3） poll机制的特点

•fd个数不再有上限限制，可以将参数ufds想象成栈底指针，nfds是栈中元素个数，该栈可以无限制增长。 
•pollfd结构将fd信息、需要监控的事件、返回的事件分开保存，则poll返回后不会丢失fd信息和需要监控的事件信息，也就省略了select模型中前面的循环操作，但返回后的循环仍然不可避免。另外每次poll操作会自动把上次的revents清空，不需要再清理。







3.3 epoll
1） 相关API


[cpp] 
view plaincopyprint?

int epoll_create(int size);  
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);  
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);  
int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
 



[cpp] 
view plaincopyprint?

typedef union epoll_data {  
 void *ptr;  
 int fd;  
 __uint32_t u32;  
 __uint64_t u64;  
} epoll_data_t;  
  
struct epoll_event {  
 __uint32_t events;  /* Epoll events */  
 epoll_data_t data;  /* User data variable */  
};  
typedef union epoll_data {
 void *ptr;
 int fd;
 __uint32_t u32;
 __uint64_t u64;
} epoll_data_t;

struct epoll_event {
 __uint32_t events;  /* Epoll events */
 epoll_data_t data;  /* User data variable */
};

其中op的定义如下：



[cpp] 
view plaincopyprint?

op: EPOLL_CTL_ADD、EPOLL_CTL_DEL  
op: EPOLL_CTL_ADD、EPOLL_CTL_DEL


2） epoll机制的特点


•它保留了poll的两个相对与select的优点。 
•epoll_wait的参数events作为出参，直接返回了有事件发生的fd，epoll_wait的返回值既是发生事件的个数，省略了poll中返回之后的循环操作。
•不再象select、poll一样将标识符局限于fd，epoll中可以将标识符扩大为指针，大大增加了epoll模型下的灵活性。 

3） epoll机制的优点：

•支付FD的数目大(1GB内存的机器上大约是10万左右)，epoll用红黑树来存储事件。 
•只响应活跃的FD，活跃的FD会主动callback。 
•使用mmap加速内核与用户空间的消息传递。 



epoll的设计思路，是把select/poll单个的操作拆分为1个epoll_create+多个epoll_ctl+一个epoll_wait。 由于在执行epoll_create和epoll_ctrl时，已经把用户态的信息保存到内核态了，所以之后即使反复地调用epoll_wait，也不会重复地拷贝参数，扫描文件描述符，反复地把当前进程放入/放出等待队列。

4） epoll实现的服务器伪码




[cpp] 
view plaincopyprint?

....  
nfds = epoll_wait(kdpfd, events, maxfds, timeout);  
if (-1 == nfds) {   ErrorLog("epoll_wait return -1!");  }  
for (i = 0, cevents = events; i < nfds; i++, cevents++)  
{  
    iFDTemp = cevents->data.fd;  
    ......  
    if (0 != (EPOLLERR & cevents->events)) {         ......       }  
    if (0 == (EPOLLIN & cevents->events)) {         ......       }  
    if (LISTEN_SOCKET == m_pSocketInfo->m_iSocketType)  
    {  
        iNewSocket = accept(iFDTemp, (struct sockaddr *)&m_stSockAddr, (socklen_t *)&iSockAddrSize);  
        ......  
    }  
    else  
    {  
        RecvClientData(iFDTemp);  
}     
....
nfds = epoll_wait(kdpfd, events, maxfds, timeout);
if (-1 == nfds) {	ErrorLog("epoll_wait return -1!");	}
for (i = 0, cevents = events; i < nfds; i++, cevents++)
{
	iFDTemp = cevents->data.fd;
	......
	if (0 != (EPOLLERR & cevents->events)) {			......		 }
	if (0 == (EPOLLIN & cevents->events)) { 		   ......		}
	if (LISTEN_SOCKET == m_pSocketInfo->m_iSocketType)
	{
		iNewSocket = accept(iFDTemp, (struct sockaddr *)&m_stSockAddr, (socklen_t *)&iSockAddrSize);
		......
	}
	else
	{
		RecvClientData(iFDTemp);
}	


5） epoll的工作模式
•LT(Level Triggered)缺省，支持block和no-block socket。水平触发，只要buffer里有未被处理的事件，内核会不断通知你就绪未处理的FD。
•ET(Edge Triggered)，只支持no-block socket。边缘触发，只在buffer大小发生变化时通知，只通知一次，控制不当有可能丢失。


4 总结
select->poll->epoll的修改主要体现在如下几个方面：

•从readset、writeset等分离到将读写事件集中到统一的结构。 
•从阻塞操作前后的两次循环到之后的一次循环，再到精确返回有事件发生的fd。 
•从只能绑定fd信息，到可以绑定指针结构信息。
下图展示了其在性能方面的测试情况：

性能对比图


 

本文内容有借鉴《Netty权威指南》的部分内容

Linux网络IO模型
首先说一下一个文件描述符（file descriptor）fd的概念，在Linux中，一切都可以视作文件，对一个文件的读写操作就会调用内核提供的系统命令，返回一个fd，使用socket也会有fd，描述符就是一个数字，指向核内的一个结构体（文件路径，数据区等一些属性）
阻塞IO模型
最常用的IO模型，也是默认情况下的，详细说就是我们说的一个连接一个线程的模型，每一个系统调用的执行都必须在内核等待数据准备号，然后才进行下面的操作。
非阻塞IO模型
在一个操作的执行中，发起一个系统调用到内核，如果数据没有准备号，直接返回，不等待。这个模型中，我们通常需要使用一个轮询检查内核的数据状态，看是否准备好。
IO复用模型
Linux提供select/poll进程通过将一个fd或多个fd传递给select/poll系统调用，将会阻塞在select上，这样就可以侦测多个fd是否在就绪状态，select/poll是顺序检查，而且支持的fd有上限。为此还有一个epoll系统调用，它是基于事件驱动的,具体下面说.
信号驱动IO模型
是这样的一个过程,首先开启套接字信号驱动功能,并通过系统调用sigaction执行一个信号处理函数,但这个过程并不阻塞,执行完就返回了,当内核中数据准备好了,通过信号回调通知程序来取数据.
异步IO
告诉内核某个操作,并让内核在整个操作完成后通知我们.与信号调用是不同的,信号调用只是通知数据准备好了,具体的操作还得自己做,但是异步IO直接是完成任务后通知.
IO多路复用技术
有select,pselect,poll,epoll系统调用,主要的过程就是上面的IO复用模型,说下几个区别

fd上限

select : 32位1024,64位2048个epoll并没有这个限制,虽然不是绝对的无上限,但是大到不用考虑这个问题


效率: select/poll是一个轮询检查的过程,当有一个很大的fd集合,但是活跃的又没多少个,这时,select的效率就很低了,但是在同样的情况下,使用epoll就很好,上面也说到了,epoll是事件驱动的,也就是说有一个回调的过程,epoll有三个函数,epoll_create,epoll_ctl,epoll_wait,create是一个创建epoll的过程,当调用ctl的时候,将用户态的fd发送到内核态,这些fd会有一个回调函数,当准备好的时候,将其fd加入到一个就绪队列中,当使用wait时,我们只检查这些就绪队列中的fd,很显然,效率不是一个层面的
内存复制的不同,epoll会使用mmap实现公用内存,mmap是零拷贝技术的一种
加一篇博客: IO多路复用,很详细

原文链接：链接

首先，要从你常用的IO操作谈起，比如read和write，通常IO操作都是阻塞I/O的，也就是说当你调用read时，如果没有数据收到，那么线程或者进程就会被挂起，直到收到数据。




（图片来源：http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/ch06lev1sec2.htmll）



这样，当服务器需要处理1000个连接的的时候，而且只有很少连接忙碌的，那么会需要1000个线程或进程来处理1000个连接，而1000个线程大部分是被阻塞起来的。由于CPU的核数或超线程数一般都不大，比如4,8,16,32,64,128，比如4个核要跑1000个线程，那么每个线程的时间槽非常短，而线程切换非常频繁。这样是有问题的：

线程是有内存开销的，1个线程可能需要512K（或2M）存放栈，那么1000个线程就要512M（或2G）内存。
	
线程的切换，或者说上下文切换是有CPU开销的，当大量时间花在上下文切换的时候，分配给真正的操作的CPU就要少很多。


那么，我们就要引入非阻塞I/O的概念，非阻塞IO很简单，通过fcntl（POSIX）或ioctl（Unix）设为非阻塞模式，这时，当你调用read时，如果有数据收到，就返回数据，如果没有数据收到，就立刻返回一个错误，如EWOULDBLOCK。这样是不会阻塞线程了，但是你还是要不断的轮询来读取或写入。


（图片来源：http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/ch06lev1sec2.htmll）




于是，我们需要引入IO多路复用的概念。多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）。


（图片来源：http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/ch06lev1sec2.htmll）


这样在处理1000个连接时，只需要1个线程监控就绪状态，对就绪的每个连接开一个线程处理就可以了，这样需要的线程数大大减少，减少了内存开销和上下文切换的CPU开销。


使用select函数的方式如下图所示：
（图片来源：