高并发系统设计

注：本文大多数观点和代码都是从网上或者开源代码中抄来的，为了疏理和组织这片文章，作者也费了不少心血，为了表示对我劳动的尊重，请转载时注明作者和出处。

一、引子

最近失业在家，闲来无事。通过网上查找资料和查看开源代码，研究了一下互联网高并发系统的一些设计。这里主要从服务器内部设计和整个系统设计两个方面讨论，更多的是从互联网大型网站设计方面考虑，高性能计算之类系统没有研究过。

二、服务器内部设计

服务器设计涉及Socket的阻塞/非阻塞，操作系统IO的同步和异步（之前被人问到过两次。第一次让我说说知道的网络模型，我说ISO模型和TCP/IP模型，结果被鄙视了。最后人说了解linux epoll吗？不了解呀！汉，回去查资料才知道是这回事。第二次让我说说知道线程模型，汉！这个名词感觉没有听说过,线程？模型？半同步/半异步，领导者/跟随者知道吗。再汉，我知道同步/异步，还有半同步/半异步？啥呀？领导者/跟随者，我现在没有领导。回去一顿恶补，原来是ACE框架里边经常有这样的提法，Reactor属于同步/半同步，PREACTOR属于领导者/跟随者模式。瀑布汗。小插曲一段，这些不懂没关系，下边我慢慢分解），事件分离器，线程池等。内部设计希望通过各个模块的给出一个简单设计，经过您的进一步的组合和打磨，就可以实现一个基本的高并发服务器。

1.Java高并发服务器

Java设计高并发服务器相对比较简单。直接是用ServerSocket或者Channel+selector实现。前者属于同步IO设计，后者采用了模拟的异步IO。为什么说模拟的异步IO呢？记得网上看到一篇文章分析了java的selector。在windows上通过建立一个127.0.0.1到127.0.0.1的连接实现IO的异步通知。在linux上通过建立一个管道实现IO的异步通知。考虑到高并并发系统的要求和java上边的异步IO的限制（通常操作系统同时打开的文件数是有限制的）和效率问题，java的高并发服务器设计不做展开深入的分析，可以参考C高并发服务器的分析做同样的设计。

2.C高并发服务器设计

1)基本概念

Ø阻塞和非阻塞socket

所谓阻塞Socket，是指其完成指定的任务之前不允许程序调用另一个函数，在Windows下还会阻塞本线程消息的发送。所谓非阻塞Socket，是指操作启动之后，如果可以立即得到结果就返回结果，否则返回表示结果需要等待的错误信息，不等待任务完成函数就返回。一个比较有意思的问题是accept的Socket是阻塞的还是非阻塞的呢？下边是MSDN上边的一段话：The accept function extracts thefirst connection on the queue of pending connections on socket s. It thencreates and returns a handle to the new socket. The newly created socket is thesocket that will handle the actual connection; it has the same properties assocket s, including the asynchronous events registered with the WSAAsyncSelector WSAEventSelect functions.

Ø同步/异步IO

有两种类型的文件IO同步：同步文件IO和异步文件IO。异步文件IO也就是重叠IO。
在同步文件IO中，线程启动一个IO操作然后就立即进入等待状态，直到IO操作完成后才醒来继续执行。而异步文件IO方式中，线程发送一个IO请求到内核，然后继续处理其他的事情，内核完成IO请求后，将会通知线程IO操作完成了。
如果IO请求需要大量时间执行的话，异步文件IO方式可以显著提高效率，因为在线程等待的这段时间内，CPU将会调度其他线程进行执行，如果没有其他线程需要执行的话，这段时间将会浪费掉（可能会调度操作系统的零页线程）。如果IO请求操作很快，用异步IO方式反而还低效，还不如用同步IO方式。
同步IO在同一时刻只允许一个IO操作，也就是说对于同一个文件句柄的IO操作是序列化的，即使使用两个线程也不能同时对同一个文件句柄同时发出读写操作。重叠IO允许一个或多个线程同时发出IO请求。异步IO在请求完成时，通过将文件句柄设为有信号状态来通知应用程序，或者应用程序通过GetOverlappedResult察看IO请求是否完成，也可以通过一个事件对象来通知应用程序。高并发系统通常采用异步IO方式提高系统性能。

Ø事件分离器

事件分离器的概念是针对异步IO来说的。在同步IO的情况下，执行操作等待返回结果，不要事件分离器。异步IO的时候，发送请求后，结果是通过事件通知的。这是产生了事件分离器的需求。事件分离器主要任务是管理和分离不同文件描述符上的所发生的事件，让后通知相应的事件，派发相应的动作。下边是lighthttpd事件分离器定义：

/**
*fd-eventhandlerforselect(),poll()andrt-signalsonLinux2.4
*
*/
typedefstructfdevents{
fdevent_handler_ttype;

fdnode**fdarray;
size_tmaxfds;

#ifdefUSE_LINUX_SIGIO
intin_sigio;
intsignum;
sigset_tsigset;
siginfo_tsiginfo;
bitset*sigbset;
#endif
#ifdefUSE_LINUX_EPOLL
intepoll_fd;
structepoll_event*epoll_events;
#endif
#ifdefUSE_POLL
structpollfd*pollfds;

size_tsize;
size_tused;

buffer_intunused;
#endif
#ifdefUSE_SELECT
fd_setselect_read;
fd_setselect_write;
fd_setselect_error;

fd_setselect_set_read;
fd_setselect_set_write;
fd_setselect_set_error;

intselect_max_fd;
#endif
#ifdefUSE_SOLARIS_DEVPOLL
intdevpoll_fd;
structpollfd*devpollfds;
#endif
#ifdefUSE_FREEBSD_KQUEUE
intkq_fd;
structkevent*kq_results;
bitset*kq_bevents;
#endif
#ifdefUSE_SOLARIS_PORT
intport_fd;
#endif
int(*reset)(structfdevents*ev);
void(*free)(structfdevents*ev);

int(*event_add)(structfdevents*ev,intfde_ndx,intfd,intevents);
int(*event_del)(structfdevents*ev,intfde_ndx,intfd);
int(*event_get_revent)(structfdevents*ev,size_tndx);
int(*event_get_fd)(structfdevents*ev,size_tndx);

int(*event_next_fdndx)(structfdevents*ev,intndx);

int(*poll)(structfdevents*ev,inttimeout_ms);

int(*fcntl_set)(structfdevents*ev,intfd);
}fdevents;

fdevents*fdevent_init(size_tmaxfds,fdevent_handler_ttype);
intfdevent_reset(fdevents*ev);
voidfdevent_free(fdevents*ev);

intfdevent_event_add(fdevents*ev,int*fde_ndx,intfd,intevents);
intfdevent_event_del(fdevents*ev,int*fde_ndx,intfd);
intfdevent_event_get_revent(fdevents*ev,size_tndx);
intfdevent_event_get_fd(fdevents*ev,size_tndx);
fdevent_handlerfdevent_get_handler(fdevents*ev,intfd);
void*fdevent_get_context(fdevents*ev,intfd);

intfdevent_event_next_fdndx(fdevents*ev,intndx);

intfdevent_poll(fdevents*ev,inttimeout_ms);

intfdevent_register(fdevents*ev,intfd,fdevent_handlerhandler,void*ctx);
intfdevent_unregister(fdevents*ev,intfd);

intfdevent_fcntl_set(fdevents*ev,intfd);

intfdevent_select_init(fdevents*ev);
intfdevent_poll_init(fdevents*ev);
intfdevent_linux_rtsig_init(fdevents*ev);
intfdevent_linux_sysepoll_init(fdevents*ev);
intfdevent_solaris_devpoll_init(fdevents*ev);
intfdevent_freebsd_kqueue_init(fdevents*ev);

具体系统的事件操作通过：

fdevent_freebsd_kqueue.c

fdevent_linux_rtsig.c

fdevent_linux_sysepoll.c

fdevent_poll.c

fdevent_select.c

fdevent_solaris_devpoll.c

几个文件实现。

Ø线程池

线程池基本上比较简单，实现线程的借入和借出，创建和销毁。最完好可以做到通过一个事件触发一个线程开始工作。下边给出一个简单的，没有实现根据事件触发的，linux和windows通用的线程池模型：

spthread.h
#ifndef__spthread_hpp__
#define__spthread_hpp__

#ifndefWIN32

///pthread

#include
#include

typedefvoid*sp_thread_result_t;
typedefpthread_mutex_tsp_thread_mutex_t;
typedefpthread_cond_tsp_thread_cond_t;
typedefpthread_tsp_thread_t;
typedefpthread_attr_tsp_thread_attr_t;

#definesp_thread_mutex_init(m,a)pthread_mutex_init(m,a)
#definesp_thread_mutex_destroy(m)pthread_mutex_destroy(m)
#definesp_thread_mutex_lock(m)pthread_mutex_lock(m)
#definesp_thread_mutex_unlock(m)pthread_mutex_unlock(m)

#definesp_thread_cond_init(c,a)pthread_cond_init(c,a)
#definesp_thread_cond_destroy(c)pthread_cond_destroy(c)
#definesp_thread_cond_wait(c,m)pthread_cond_wait(c,m)
#definesp_thread_cond_signal(c)pthread_cond_signal(c)

#definesp_thread_attr_init(a)pthread_attr_init(a)
#definesp_thread_attr_setdetachstatepthread_attr_setdetachstate
#defineSP_THREAD_CREATE_DETACHEDPTHREAD_CREATE_DETACHED

#definesp_thread_selfpthread_self
#definesp_thread_createpthread_create

#defineSP_THREAD_CALL
typedefsp_thread_result_t(*sp_thread_func_t)(void*args);

#definesp_sleep(x)sleep(x)

#else///////////////////////////////////////////////////////////////////////

//win32thread

#include
#include

typedefunsignedsp_thread_t;

typedefunsignedsp_thread_result_t;
#defineSP_THREAD_CALL__stdcall
typedefsp_thread_result_t(__stdcall*sp_thread_func_t)(void*args);

typedefHANDLEsp_thread_mutex_t;
typedefHANDLEsp_thread_cond_t;
typedefDWORDsp_thread_attr_t;

#defineSP_THREAD_CREATE_DETACHED1
#definesp_sleep(x)Sleep(1000*x)

intsp_thread_mutex_init(sp_thread_mutex_t*mutex,void*attr)
{
*mutex=CreateMutex(NULL,FALSE,NULL);
returnNULL==*mutex?GetLastError():0;
}

intsp_thread_mutex_destroy(sp_thread_mutex_t*mutex)
{
intret=CloseHandle(*mutex);

return0==ret?GetLastError():0;
}

intsp_thread_mutex_lock(sp_thread_mutex_t*mutex)
{
intret=WaitForSingleObject(*mutex,INFINITE);
returnWAIT_OBJECT_0==ret?0:GetLastError();
}

intsp_thread_mutex_unlock(sp_thread_mutex_t*mutex)
{
intret=ReleaseMutex(*mutex);
return0!=ret?0:GetLastError();
}

intsp_thread_cond_init(sp_thread_cond_t*cond,void*attr)
{
*cond=CreateEvent(NULL,FALSE,FALSE,NULL);
returnNULL==*cond?GetLastError():0;
}

intsp_thread_cond_destroy(sp_thread_cond_t*cond)
{
intret=CloseHandle(*cond);
return0==ret?GetLastError():0;
}

/*
CallerMUSTbeholdingthemutexlock;the
lockisreleasedandthecallerisblockedwaiting
on'cond'.When'cond'issignaled,themutex
isre-acquiredbeforereturningtothecaller.
*/
intsp_thread_cond_wait(sp_thread_cond_t*cond,sp_thread_mutex_t*mutex)
{
intret=0;

sp_thread_mutex_unlock(mutex);

ret=WaitForSingleObject(*cond,INFINITE);

sp_thread_mutex_lock(mutex);

returnWAIT_OBJECT_0==ret?0:GetLastError();
}

intsp_thread_cond_signal(sp_thread_cond_t*cond)
{
intret=SetEvent(*cond);
return0==ret?GetLastError():0;
}

sp_thread_tsp_thread_self()
{
returnGetCurrentThreadId();
}

intsp_thread_attr_init(sp_thread_attr_t*attr)
{
*attr=0;
return0;
}

intsp_thread_attr_setdetachstate(sp_thread_attr_t*attr,intdetachstate)
{
*attr|=detachstate;
return0;
}

intsp_thread_create(sp_thread_t*thread,sp_thread_attr_t*attr,
sp_thread_func_tmyfunc,void*args)
{
//_beginthreadexreturns0onanerror
HANDLEh=(HANDLE)_beginthreadex(NULL,0,myfunc,args,0,thread);
returnh>0?0:GetLastError();
}

#endif

#endif
threadpool.h
/**
*threadpool.h
*
*Thisfiledeclaresthefunctionalityassociatedwith
*yourimplementationofathreadpool.
*/

#ifndef__threadpool_h__
#define__threadpool_h__

#ifdef__cplusplus
extern"C"{
#endif

//maximumnumberofthreadsallowedinapool
#defineMAXT_IN_POOL200

//Youmusthidetheinternaldetailsofthethreadpool
//structurefromcallers,thusdeclarethreadpooloftype"void".
//Inthreadpool.c,youwillusetypeconversiontocoerce
//variablesoftype"threadpool"backandforthtoa
//richer,internaltype.(Seethreadpool.cfordetails.)

typedefvoid*threadpool;

//"dispatch_fn"declaresatypedfunctionpointer.A
//variableoftype"dispatch_fn"pointstoafunction
//withthefollowingsignature:
//
//voiddispatch_function(void*arg);

typedefvoid(*dispatch_fn)(void*);

/**
*create_threadpoolcreatesafixed-sizedthread
*pool.Ifthefunctionsucceeds,itreturnsa(non-NULL)
*"threadpool",elseitreturnsNULL.
*/
threadpoolcreate_threadpool(intnum_threads_in_pool);


/**
*dispatchsendsathreadofftodosomework.If
*allthreadsinthepoolarebusy,dispatchwill
*blockuntilathreadbecomesfreeandisdispatched.
*
*Onceathreadisdispatched,thisfunctionreturns
*immediately.
*
*Thedispatchedthreadcallsintothefunction
*"dispatch_to_here"withargument"arg".
*/
intdispatch_threadpool(threadpoolfrom_me,dispatch_fndispatch_to_here,
void*arg);

/**
*destroy_threadpoolkillsthethreadpool,causing
*allthreadsinittocommitsuicide,andthen
*freesallthememoryassociatedwiththethreadpool.
*/
voiddestroy_threadpool(threadpooldestroyme);

#ifdef__cplusplus
}
#endif

#endif
threadpool.c
/**
*threadpool.c
*
*Thisfilewillcontainyourimplementationofathreadpool.
*/

#include
#include
//#include
//#include
#include

#include"threadpool.h"
#include"spthread.h"

typedefstruct_thread_st{
sp_thread_tid;
sp_thread_mutex_tmutex;
sp_thread_cond_tcond;
dispatch_fnfn;
void*arg;
threadpoolparent;
}_thread;

//_threadpoolistheinternalthreadpoolstructurethatis
//casttotype"threadpool"beforeitgivenouttocallers
typedefstruct_threadpool_st{
//youshouldfillinthisstructurewithwhateveryouneed
sp_thread_mutex_ttp_mutex;
sp_thread_cond_ttp_idle;
sp_thread_cond_ttp_full;
sp_thread_cond_ttp_empty;
_thread**tp_list;
inttp_index;
inttp_max_index;
inttp_stop;

inttp_total;
}_threadpool;

threadpoolcreate_threadpool(intnum_threads_in_pool)
{
_threadpool*pool;

//sanitychecktheargument
if((num_threads_in_pool<=0)||(num_threads_in_pool>MAXT_IN_POOL))
returnNULL;

pool=(_threadpool*)malloc(sizeof(_threadpool));
if(pool==NULL){
fprintf(stderr,"Outofmemorycreatinganewthreadpool!n");
returnNULL;
}

//addyourcodeheretoinitializethenewlycreatedthreadpool
sp_thread_mutex_init(&pool->tp_mutex,NULL);
sp_thread_cond_init(&pool->tp_idle,NULL);
sp_thread_cond_init(&pool->tp_full,NULL);
sp_thread_cond_init(&pool->tp_empty,NULL);
pool->tp_max_index=num_threads_in_pool;
pool->tp_index=0;
pool->tp_stop=0;
pool->tp_total=0;
pool->tp_list=(_thread**)malloc(sizeof(void*)*MAXT_IN_POOL);
memset(pool->tp_list,0,sizeof(void*)*MAXT_IN_POOL);

return(threadpool)pool;
}

intsave_thread(_threadpool*pool,_thread*thread)
{
intret=-1;

sp_thread_mutex_lock(&pool->tp_mutex);

if(pool->tp_indextp_max_index){
pool->tp_list[pool->tp_index]=thread;
pool->tp_index++;
ret=0;

sp_thread_cond_signal(&pool->tp_idle);

if(pool->tp_index>=pool->tp_total){
sp_thread_cond_signal(&pool->tp_full);
}
}

sp_thread_mutex_unlock(&pool->tp_mutex);

returnret;
}

sp_thread_result_tSP_THREAD_CALLwrapper_fn(void*arg)
{
_thread*thread=(_thread*)arg;
_threadpool*pool=(_threadpool*)thread->parent;

for(;0==((_threadpool*)thread->parent)->tp_stop;){
thread->fn(thread->arg);

if(0!=((_threadpool*)thread->parent)->tp_stop)break;

sp_thread_mutex_lock(&thread->mutex);
if(0==save_thread(thread->parent,thread)){
sp_thread_cond_wait(&thread->cond,&thread->mutex);
sp_thread_mutex_unlock(&thread->mutex);
}else{
sp_thread_mutex_unlock(&thread->mutex);
sp_thread_cond_destroy(&thread->cond);
sp_thread_mutex_destroy(&thread->mutex);

free(thread);
break;
}
}

sp_thread_mutex_lock(&pool->tp_mutex);
pool->tp_total--;
if(pool->tp_total<=0)sp_thread_cond_signal(&pool->tp_empty);
sp_thread_mutex_unlock(&pool->tp_mutex);

return0;
}

intdispatch_threadpool(threadpoolfrom_me,dispatch_fndispatch_to_here,void*arg)
{
intret=0;

_threadpool*pool=(_threadpool*)from_me;
sp_thread_attr_tattr;
_thread*thread=NULL;

//addyourcodeheretodispatchathread
sp_thread_mutex_lock(&pool->tp_mutex);

if(pool->tp_index<=0&&pool->tp_total>=pool->tp_max_index){
sp_thread_cond_wait(&pool->tp_idle,&pool->tp_mutex);
}

if(pool->tp_index<=0){
_thread*thread=(_thread*)malloc(sizeof(_thread));
memset(&(thread->id),0,sizeof(thread->id));
sp_thread_mutex_init(&thread->mutex,NULL);
sp_thread_cond_init(&thread->cond,NULL);
thread->fn=dispatch_to_here;
thread->arg=arg;
thread->parent=pool;

sp_thread_attr_init(&attr);
sp_thread_attr_setdetachstate(&attr,SP_THREAD_CREATE_DETACHED);

if(0==sp_thread_create(&thread->id,&attr,wrapper_fn,thread)){
pool->tp_total++;
printf("createthread#%ldn",thread->id);
}else{
ret=-1;
printf("cannotcreatethreadn");
sp_thread_mutex_destroy(&thread->mutex);
sp_thread_cond_destroy(&thread->cond);
free(thread);
}
}else{
pool->tp_index--;
thread=pool->tp_list[pool->tp_index];
pool->tp_list[pool->tp_index]=NULL;

thread->fn=dispatch_to_here;
thread->arg=arg;
thread->parent=pool;

sp_thread_mutex_lock(&thread->mutex);
sp_thread_cond_signal(&thread->cond);
sp_thread_mutex_unlock(&thread->mutex);
}

sp_thread_mutex_unlock(&pool->tp_mutex);

returnret;
}

voiddestroy_threadpool(threadpooldestroyme)
{
_threadpool*pool=(_threadpool*)destroyme;

//addyourcodeheretokillathreadpool
inti=0;

sp_thread_mutex_lock(&pool->tp_mutex);

if(pool->tp_indextp_total){
printf("waitingfor%dthread(s)tofinishn",pool->tp_total-pool->tp_index);
sp_thread_cond_wait(&pool->tp_full,&pool->tp_mutex);
}

pool->tp_stop=1;

for(i=0;itp_index;i++){
_thread*thread=pool->tp_list[i];

sp_thread_mutex_lock(&thread->mutex);
sp_thread_cond_signal(&thread->cond);
sp_thread_mutex_unlock(&thread->mutex);
}

if(pool->tp_total>0){
printf("waitingfor%dthread(s)toexitn",pool->tp_total);
sp_thread_cond_wait(&pool->tp_empty,&pool->tp_mutex);
}

for(i=0;itp_index;i++){
free(pool->tp_list[i]);
pool->tp_list[i]=NULL;
}

sp_thread_mutex_unlock(&pool->tp_mutex);

pool->tp_index=0;

sp_thread_mutex_destroy(&pool->tp_mutex);
sp_thread_cond_destroy(&pool->tp_idle);
sp_thread_cond_destroy(&pool->tp_full);
sp_thread_cond_destroy(&pool->tp_empty);

free(pool->tp_list);
free(pool);
}

2)常见的设计模式

根据Socket的阻塞非阻塞，IO的同步和异步。可以分为如下4中情形

阻塞同步 | 阻塞异步

_________|______________

非阻塞同步 | 非阻塞异步

阻塞同步方式是原始的方式，也是许多教科书上介绍的方式，因为Socket和IO默认的为阻塞和同步方式。基本流程如下：

listen_fd=socket(AF_INET,SOCK_STREAM,0)
bind(listen_fd,(structsockaddr*)&my_addr,sizeof(structsockaddr_in))
listen(listen_fd,1)
accept(listen_fd,(structsockaddr*)&remote_addr,&addr_len)
recv(accept_fd,&in_buf,1024,0)
close(accept_fd)

阻塞异步方式有所改进，但是Socket的阻塞方式，前一个连接没有处理完成，下一个连接不能接入，是高并发服务器所不可接收的方式。只不过在上边阻塞同步方式的基础上使用select（严格来说select是一种IO多路服用技术。因为linux尚没有完整的实现异步IO，而winsock实在理解socket没有linux上面那么直观。，这里为了方便，没有做严格的区分）或者其它异步IO方式。

非阻塞同步方式，通过设置socket选项为NONBLOCK，可以很快的接收连接，但是处理采用同步IO方式，服务器处理性能也比较差。

上边三种方式不做深入介绍。下边主要从非阻塞异步IO方式介绍。

非阻塞异步IO方式中，由于异步IO方式在同一系统可能有多种实现，不同系统也有不同实现，下边介绍几种常见的IO方式和服务器框架。

ØSelect

Select采用轮训注册的fd方式。是一种比较老的IO多路服用实现方式，效率相对要差一些。Select方式在windows和linux上都支持。

基本框架如下：

socket(AF_INET,SOCK_STREAM,0)
fcntl(listen_fd,F_SETFL,flags|O_NONBLOCK);
bind(listen_fd,(structsockaddr*)&my_addr,sizeof(structsockaddr_in))
listen(listen_fd,1)
FD_ZERO(&fd_sets);
FD_SET(listen_fd,&fd_sets);
for(k=0;k<=i;k++){
FD_SET(accept_fds[k],&fd_sets);
}
events=select(max_fd+1,&fd_sets,NULL,NULL,NULL);
if(FD_ISSET(listen_fd,&fd_sets)){
accept_fd=accept(listen_fd,(structsockaddr*)&remote_addr,&addr_len);
}
for(j=0;j<=i;j++){
if(FD_ISSET(accept_fds[j],&fd_sets)){
recv(accept_fds[j],&in_buf,1024,0);
}
}

ØEpoll

Epoll是linux2.6内核以后支持的一种高性能的IO多路服用技术。服务器框架如下：

socket(AF_INET,SOCK_STREAM,0)
fcntl(listen_fd,F_SETFL,flags|O_NONBLOCK);
bind(listen_fd,(structsockaddr*)&my_addr,sizeof(structsockaddr_in))
listen(listen_fd,1)
epoll_ctl(epfd,EPOLL_CTL_ADD,listen_fd,&ev);
ev_s=epoll_wait(epfd,events,20,500);
for(i=0;i
if(events[i].data.fd==listen_fd){
accept_fd=accept(listen_fd,(structsockaddr*)&remote_addr,&addr_len);
fcntl(accept_fd,F_SETFL,flags|O_NONBLOCK);
epoll_ctl(epfd,EPOLL_CTL_ADD,accept_fd,&ev);
}
elseif(events[i].events&EPOLLIN){
recv(events[i].data.fd,&in_buf,1024,0);
}
}

ØAIO

在windows上微软实现了异步IO，通过AIO可以方便的实现高并发的服务器。框架如下：

WSAStartup(0x0202,&wsaData)
CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0)
WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED)
bind(Listen,(PSOCKADDR)&InternetAddr,sizeof(InternetAddr))
listen(Listen,5)
WSAAccept(Listen,NULL,NULL,NULL,0)
PerHandleData=(LPPER_HANDLE_DATA)GlobalAlloc(GPTR,sizeof(PER_HANDLE_DATA)
CreateIoCompletionPort((HANDLE)Accept,CompletionPort,(DWORD)PerHandleData,0)
PerIoData=(LPPER_IO_OPERATION_DATA)GlobalAlloc(GPTR,sizeof(PER_IO_OPERATION_DATA))
WSARecv(Accept,&(PerIoData->DataBuf),1,&RecvBytes,&Flags,&(PerIoData->Overlapped),NULL)
(GetQueuedCompletionStatus(CompletionPort,&BytesTransferred,
(LPDWORD)&PerHandleData,(LPOVERLAPPED*)&PerIoData,INFINITE)
if(PerIoData->BytesRECV>PerIoData->BytesSEND){
WSASend(PerHandleData->Socket,&(PerIoData->DataBuf),1,&SendBytes,0,
&(PerIoData->Overlapped),NULL)
}

3)引入线程池和事件分离器后

由于上边只是单纯的使用非阻塞Socket和异步IO的方式。提高了接收连接和处理的速度。但是还是不能解决两个客户端同时连接的问题。这时就需要引入多线程机制。引入多线程后，又有许多策略。Linux上通常采用主进程负责接收连接，之后fork子进程处理连接。Windows通常采用线程池方式，避免线程创建和销毁的开销，当然linux上也可以采用线程池方式。采用多进程和多线程方式后。事件处理也可以再优化，定义一个简单的事件处理器，把所有事件放入一个队列，各个线程去事件队列取相应的事件，然后自己开始工作。这就是我上边提到的半同步/半异步方式了。如果线程工作的时候是接收到连接后，自己处理后续的发送和接收，然后选出另外一个线程作为领导继续接收连接，其它线程作为追随者。这就是领导者/追随者模式了。具体可以参考ACE的Reactor和Preactor的具体实现。半同步和/半异步网上也有很多的讨论，可以自己深入研究。代码就比较复杂了，这里就不给出代码了。给出一个linux下类似，相对简单的fork子进程+epoll方式的实现：

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#defineHANDLE_INFO1
#defineHANDLE_SEND2
#defineHANDLE_DEL3
#defineHANDLE_CLOSE4

#defineMAX_REQLEN1024
#defineMAX_PROCESS_CONN3
#defineFIN_CHAR0x00
#defineSUCCESS0
#defineERROR-1

typedefstructevent_handle{
intsocket_fd;
intfile_fd;
intfile_pos;
intepoll_fd;
charrequest[MAX_REQLEN];
intrequest_len;
int(*read_handle)(structevent_handle*ev);
int(*write_handle)(structevent_handle*ev);
inthandle_method;
}EV,*EH;
typedefint(*EVENT_HANDLE)(structevent_handle*ev);

intcreate_listen_fd(intport){
intlisten_fd;
structsockaddr_inmy_addr;
if((listen_fd=socket(AF_INET,SOCK_STREAM,0))==-1){
perror("createsocketerror");
exit(1);
}
intflag;
intolen=sizeof(int);
if(setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR
,(constvoid*)&flag,olen)==-1){
perror("setsockopterror");
}
flag=5;
if(setsockopt(listen_fd,IPPROTO_TCP,TCP_DEFER_ACCEPT,&flag,olen)==-1){
perror("setsockopterror");
}
flag=1;
if(setsockopt(listen_fd,IPPROTO_TCP,TCP_CORK,&flag,olen)==-1){
perror("setsockopterror");
}
intflags=fcntl(listen_fd,F_GETFL,0);
fcntl(listen_fd,F_SETFL,flags|O_NONBLOCK);
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(port);
my_addr.sin_addr.s_addr=INADDR_ANY;
bzero(&(my_addr.sin_zero),8);
if(bind(listen_fd,(structsockaddr*)&my_addr,
sizeof(structsockaddr_in))==-1){
perror("binderror");
exit(1);
}
if(listen(listen_fd,1)==-1){
perror("listenerror");
exit(1);
}
returnlisten_fd;
}

intcreate_accept_fd(intlisten_fd){
intaddr_len=sizeof(structsockaddr_in);
structsockaddr_inremote_addr;
intaccept_fd=accept(listen_fd,
(structsockaddr*)&remote_addr,&addr_len);
intflags=fcntl(accept_fd,F_GETFL,0);
fcntl(accept_fd,F_SETFL,flags|O_NONBLOCK);
returnaccept_fd;
}

intfork_process(intprocess_num){
inti;
intpid=-1;
for(i=0;i
if(pid!=0){
pid=fork();
}
}
returnpid;
}

intinit_evhandle(EHev,intsocket_fd,intepoll_fd,EVENT_HANDLEr_handle,EVENT_HANDLEw_handle){
ev->epoll_fd=epoll_fd;
ev->socket_fd=socket_fd;
ev->read_handle=r_handle;
ev->write_handle=w_handle;
ev->file_pos=0;
ev->request_len=0;
ev->handle_method=0;
memset(ev->request,0,1024);
}
//accept->accept_queue->request->request_queue->output->output_queue
//multiprocesssendfile
intparse_request(EHev){
ev->request_len--;
*(ev->request+ev->request_len-1)=0x00;
inti;
for(i=0;irequest_len;i++){
if(ev->request[i]==':'){
ev->request_len=ev->request_len-i-1;
chartemp[MAX_REQLEN];
memcpy(temp,ev->request,i);
ev->handle_method=atoi(temp);
memcpy(temp,ev->request+i+1,ev->request_len);
memcpy(ev->request,temp,ev->request_len);
break;
}
}
//handle_request(ev);
//registertoepollEPOLLOUT

structepoll_eventev_temp;
ev_temp.data.ptr=ev;
ev_temp.events=EPOLLOUT|EPOLLET;
epoll_ctl(ev->epoll_fd,EPOLL_CTL_MOD,ev->socket_fd,&ev_temp);
returnSUCCESS;
}

inthandle_request(EHev){
structstatfile_info;
switch(ev->handle_method){
caseHANDLE_INFO:
ev->file_fd=open(ev->request,O_RDONLY);
if(ev->file_fd==-1){
send(ev->socket_fd,"openfilefailedn",strlen("openfilefailedn"),0);
return-1;
}
fstat(ev->file_fd,&file_info);
charinfo[MAX_REQLEN];
sprintf(info,"filelen:%dn",file_info.st_size);
send(ev->socket_fd,info,strlen(info),0);
break;
caseHANDLE_SEND:
ev->file_fd=open(ev->request,O_RDONLY);
if(ev->file_fd==-1){
send(ev->socket_fd,"openfilefailedn",strlen("openfilefailedn"),0);
return-1;
}
fstat(ev->file_fd,&file_info);
sendfile(ev->socket_fd,ev->file_fd,0,file_info.st_size);
break;
caseHANDLE_DEL:
break;
caseHANDLE_CLOSE:
break;
}
finish_request(ev);
returnSUCCESS;
}

intfinish_request(EHev){
close(ev->socket_fd);
close(ev->file_fd);
ev->handle_method=-1;
clean_request(ev);
returnSUCCESS;
}

intclean_request(EHev){
memset(ev->request,0,MAX_REQLEN);
ev->request_len=0;
}

intread_hook_v2(EHev){
charin_buf[MAX_REQLEN];
memset(in_buf,0,MAX_REQLEN);
intrecv_num=recv(ev->socket_fd,&in_buf,MAX_REQLEN,0);
if(recv_num==0){
close(ev->socket_fd);
returnERROR;
}
else{
//checkifoverflow
if(ev->request_len>MAX_REQLEN-recv_num){
close(ev->socket_fd);
clean_request(ev);
}
memcpy(ev->request+ev->request_len,in_buf,recv_num);
ev->request_len+=recv_num;
if(recv_num==2&&(!memcmp(&in_buf[recv_num-2],"rn",2))){
parse_request(ev);
}
}
returnrecv_num;
}

intwrite_hook_v1(EHev){
structstatfile_info;
ev->file_fd=open(ev->request,O_RDONLY);
if(ev->file_fd==ERROR){
send(ev->socket_fd,"openfilefailedn",strlen("openfilefailedn"),0);
returnERROR;
}
fstat(ev->file_fd,&file_info);
intwrite_num;
while(1){
write_num=sendfile(ev->socket_fd,ev->file_fd,(off_t*)&ev->file_pos,10240);
ev->file_pos+=write_num;
if(write_num==ERROR){
if(errno==EAGAIN){
break;
}
}
elseif(write_num==0){
printf("writed:%dn",ev->file_pos);
//finish_request(ev);
break;
}
}
returnSUCCESS;
}

intmain(){
intlisten_fd=create_listen_fd(3389);
intpid=fork_process(3);
if(pid==0){
intaccept_handles=0;
structepoll_eventev,events[20];
intepfd=epoll_create(256);
intev_s=0;

ev.data.fd=listen_fd;
ev.events=EPOLLIN|EPOLLET;
epoll_ctl(epfd,EPOLL_CTL_ADD,listen_fd,&ev);
structevent_handleev_handles[256];
for(;;){
ev_s=epoll_wait(epfd,events,20,500);
inti=0;
for(i=0;i
if(events[i].data.fd==listen_fd){
if(accept_handles
accept_handles++;
intaccept_fd=create_accept_fd(listen_fd);
init_evhandle(&ev_handles[accept_handles],accept_fd,epfd,read_hook_v2,write_hook_v1);
ev.data.ptr=&ev_handles[accept_handles];
ev.events=EPOLLIN|EPOLLET;
epoll_ctl(epfd,EPOLL_CTL_ADD,accept_fd,&ev);
}
}
elseif(events[i].events&EPOLLIN){
EVENT_HANDLEcurrent_handle=((EH)(events[i].data.ptr))->read_handle;
EHcurrent_event=(EH)(events[i].data.ptr);
(*current_handle)(current_event);
}
elseif(events[i].events&EPOLLOUT){
EVENT_HANDLEcurrent_handle=((EH)(events[i].data.ptr))->write_handle;
EHcurrent_event=(EH)(events[i].data.ptr);
if((*current_handle)(current_event)==0){
accept_handles--;
}
}
}
}
}
else{
//managertheprocess
intchild_process_status;
wait(&child_process_status);
}

returnSUCCESS;
}

三、分布式系统设计

前面讲述了分布式系统中的核心的服务器的实现。可以是http服务器，缓存服务器，分布式文件系统等的内部实现。下边主要从一个高并发的大型网站出发，看一个高并发系统的设计。下边是一个高并发系统的逻辑结构：

主要是参考这篇文章http://www.chinaz.com/web/2010/0310/108211.shtml。下边主要想从这个架构的各个部分的实现展开。

1.缓存系统

缓存是每一个高并发，高可用系统不可或缺的模块。下边就几个常见缓存系统系统进行介绍。

Squid

Squid作为一个前端缓存，通常部署在网络的离用户最近的地方，通过缓存网站的页面，使用户不必每次都跑到服务器去取数据，提高系统响应和性能。实现应该比较简单：一个带有存储功能的代理。用户访问页面的时候，由它代理，然后存储请求结果，下次再访问的时候，查看是否需要更新，有更新就去服务器取新数据，否则直接返回用户页面。

Ehcache

Ehcache是一个对象缓存系统。通常在J2EE中配合Hibernate使用，这里请原谅作者本人之前是做J2EE开发的，其它使用方式暂不是很了解。应用查询数据库，对经常需要查询，却更新不频繁的数据，可以放入ehcache缓存，提高访问速度。Ehcahe支持内存缓存和硬盘两种方式，支持分布式缓存。数据缓存的基本原理就是：为需要缓存的对象建立一个map，临时对象放入map，查询的时候先查询map，没有找到再查找数据库。关机时可以序列化到硬盘。分布式缓存没有研究过。

页面缓存和动态页面静态化

在大型网站经常使用的一种缓存技术就是动态页面的缓存。由于动态页面经常更新，上边的缓存就不起作用了。通常会采用SSI(Server side include)等技术将动态页面的或者页面片段进行缓存。

还有一种就是动态页面静态化。下边是一本讲spring的书中给出的j2EE中的动态页面静态化的示例：

/**
*动态内容静态化的Filter。将变化非常缓慢的动态文件生成静态文件。
*/
packagecom.zsl.cache.filter;

importjava.io.File;
importjava.io.IOException;
importjava.io.UnsupportedEncodingException;
importjava.net.URLEncoder;
importjava.util.Map;

importjavax.management.RuntimeErrorException;
importjavax.servlet.FilterChain;
importjavax.servlet.ServletException;
importjavax.servlet.ServletRequest;
importjavax.servlet.ServletResponse;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;

importorg.apache.commons.io.FilenameUtils;
importorg.apache.http.HttpResponse;
importorg.springframework.core.io.Resource;

importcom.sun.xml.bind.v2.runtime.output.Encoded;


/**
*@authorzsl
*
*/
publicclassFileCacheFilterextendsAbstractCacheFilter{
privateStringroot;

privatefinalStringSUFFIX=".html";

publicfinalvoidsetFileDir(Resourcedir){
try{
Filef=dir.getFile();
f.mkdirs();
if(!f.isDirectory()){
thrownewIllegalArgumentException("Invaliddirectory:"+f.getPath());
}
if(!f.canWrite())
thrownewIllegalArgumentException("Cannotwritetodirectory:"+f.getPath());
root=f.getPath();

if(!root.endsWith("/")&&!root.endsWith("//"))
root=root+"/";
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
thrownewIllegalArgumentException(e);
}
}

publicvoidafterPropertiesSet()throwsException{
super.afterPropertiesSet();
if(!newFile(root).isDirectory()){
thrownewIllegalArgumentException("Nodirectory:"+root);
}
}

publicvoiddoFilter(ServletRequestrequest,ServletResponseresponse,FilterChainchain)throwsIOException,ServletException{
HttpServletRequesthttpRequest=(HttpServletRequest)request;
Stringkey=getKey(httpRequest);
if(key==null){
chain.doFilter(request,response);
}else{
Filefile=key2File(key);
if(file.isFile()){
HttpServletResponsehttpResponse=(HttpServletResponse)response;
httpResponse.setContentType(getContentType());
httpResponse.setHeader("Content-Encoding","gzip");
httpResponse.setContentLength((int)file.length());
FileUtil.readFil(file,httpResponse.getOutputStream());
}else{
//缓存未找到文件
HttpServletResponsehttpResponse=(HttpServletResponse)response;
CachedResponseWrapperwrapper=newCachedResponseWrapper(httpResponse);
chain.doFilter(request,response);
if(wrapper.getStatus()==HttpServletResponse.SC_OK){
byte[]data=GZipUtil.gzip(wrapper.getResponseData());
FileUtil.writeFile(file,data);
httpResponse.setContentType(getContentType());
httpResponse.setHeader("Content-Encoding","gzip");
httpResponse.setContentLength(data.length);
httpResponse.getOutputStream().write(data);
}
}
}

}

privateFilekey2File(Stringkey){
inthash=key.hashCode();
intdir1=(hash&0xff00)>>8;
intdir2=hash&0xff;
Stringdir=root+dir1+"/"+dir2;
Filefdir=newFile(dir);
if(!fdir.isAbsolute()){
if(!fdir.mkdirs()){
returnnull;
}
}
returnnewFile(dir+"/"+encode(key)+SUFFIX);
}

privateStringencode(Stringkey){
try{
returnURLEncoder.encode(key,"UTF-8");
}catch(UnsupportedEncodingExceptione){
thrownewRuntimeException(e);
}

}

publicvoidremove(Stringurl,Mapparameters){
Stringkey=getKey(HttpServletRequestFactory.create(url,parameters));
if(key!=null){
FileUtil.remveFile(key2File(key));
}
}
}

书中给到的另外一个客户端缓存，不知道该归那类：

/**
*网页静态资源（gif图像，css资源的缓存时间设置filter，避免频繁请求静态资源
*/
packagecom.zsl.cache.filter;

importjava.io.IOException;
importjava.util.Enumeration;
importjava.util.Map;

importjavax.servlet.FilterChain;
importjavax.servlet.FilterConfig;
importjavax.servlet.ServletException;
importjavax.servlet.Filter;
importjavax.servlet.ServletRequest;
importjavax.servlet.ServletResponse;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;

importorg.apache.commons.collections.map.HashedMap;
importorg.apache.commons.logging.Log;
importorg.apache.commons.logging.LogFactory;


/**
*@authorzsl
*
*/
publicclassExpireFilterimplementsFilter{

privateLoglog=LogFactory.getLog(ExpireFilter.class);

privateMapmap=newHashedMap();

@Override
publicvoiddestroy(){
log.info("destoryExpiredFilter");
}

@Override
publicvoiddoFilter(ServletRequestrequest,ServletResponseresponse,
FilterChainchain)throwsIOException,ServletException{
StringuriString=((HttpServletRequest)request).getRequestURI();
intn=uriString.lastIndexOf('.');
if(n!=-1){
Stringext=uriString.substring(n);
Longexp=map.get(ext);
if(exp!=null){
HttpServletResponseresp=(HttpServletResponse)response;
resp.setHeader("Expires",System.currentTimeMillis()+exp*1000+"");
}
}
chain.doFilter(request,response);
}

@Override
publicvoidinit(FilterConfigconfig)throwsServletException{
Enumerationem=config.getInitParameterNames();
while(em.hasMoreElements()){
StringparamName=em.nextElement().toString();
StringparamValue=config.getInitParameter(paramName);
try{
inttime=Integer.valueOf(paramValue);
if(time>0){
log.info("set"+paramName+"expiredseconds:"+time);
map.put(paramName,newLong(time));
}
}catch(Exceptione){
log.warn("ExceptionininitilizingExpiredFilter.",e);
}
}
}
}

2.负载均衡系统

Ø负载均衡策略

负载均衡策略有随机分配，平均分配，分布式一致性hash等。随机分配就是通过随机数选择一个服务器来服务。平均分配就是一次循环分配一次。分布式一致性hash算法，比较负载，把资源和节点映射到一个换上，然后通过一定的算法资源对应到节点上，使得添加和去掉服务器变得非常容易，减少对其它服务器的影响。很有名的一个算法，据说是P2P的基础。了解不是很深，就不详细说了，要露马脚了。

Ø软件负载均衡

软件负载均衡可以采用很多方案，常见的几个方案有：

基于DNS的负载均衡，通过DNS正向区域的配置，将一个域名根据一定的策略解析到多个ip地址，实现负载均衡，这里需要DNS服务器的配合。

基于LVS的负载均衡。LVS可以将多个linux服务器做成一个虚拟的服务器，对外提供服务器，实现负载均衡。

基于Iptables的负载均衡。Iptables可以通过做nat，对外提供一个虚拟IP，对内映射到多个服务器实现负载均衡。基本上可以和硬件均衡方案一致了，这里的linux服务器相当于一台路由器。

Ø硬件负载均衡

基于路由器的负载均衡，在路由器上配置nat实现负载均衡。对外网一个虚拟IP，内网映射几个内网IP。

一些网络设备厂商也提供了一些负载均衡的设备，如F5，不过价格不菲哦。

数据库的负载均衡

数据库的负载均衡可以是数据库厂商提供的集群方案。

——————————————————————————————————————

今天先写到这里，这个题目太大了，东西太多。后边是将来要写的。还没有组织出来。

好多东西也没有展开。东西太多了。

——————————————————————————————————————

分布式文件系统

Gfs

hfs

Map Reduce系统

云计算