zoukankan      html  css  js  c++  java

  • UNIX网络编程——常用服务器模型总结

    下面有9种服务器模型分别是：

    • 迭代服务器。
    • 并发服务器，为每个客户fork一个进程。
    • 预先派生子进程，每个子进程都调用accept，accept无上锁保护。
    • 预先派生子进程，以文件锁的方式保护accept。 
    • 预先派生子进程，以线程互斥锁上锁的方式保护accept。
    • 预先派生子进程，由父进程向子进程传递套接口描述字。 
    • 并发服务器，为每个客户请求创建一个线程。
    • 预先创建线程，以互斥锁上锁方式保护accept。 
    • 预先创建线程，由主线程调用accept，并把每个客户连接传递给线程池中某个可用线程。

    1、迭代服务器

           典型代码：
    [cpp] view plain copy
     
    1. socket  
    2. bind  
    3. listen  
    4. for(;;)  
    5. {  
    6. connfd = accept(listenfd, (SA*)&cliaddr, &clilen);  
    7. process_connection(connfd);  
    8. close(connfd);  
    9. }  
           优点：主要是编程简单。
           缺点：处理完一个连接之后才能处理下一个连接，无并发可言，应用很少。
     
    2.并发服务器，为每个客户fork一个进程
           典型代码：
    [cpp] view plain copy
     
    1. init_address(server_addr)  
    2. listenfd = socket(AF_INET,SOCKET_STREAM,0);  
    3. bind(listenfd, (SA*)server_addr, sizeof(serveraddr));  
    4. listen(listenfd,BACKLOG);  
    5. for(;;)  
    6. {  
    7. connfd = accept(listenfd, (SA*)&cliaddr, &clilen);  
    8. if(connfd < 0)  
    9. {  
    10. if(EINTR == errno)  
    11. continue;  
    12. else  
    13. //error  
    14. }  
    15.   
    16. if(fork() == 0)  
    17. {  
    18. close(c=listenfd);  
    19. process_connection(connfd); //child process  
    20. exit(0);  
    21. }  
    22. close(connfd);//parent, close connected socket  
    23. }  
           早期的网络服务器每天处理几百或者几千个客户连接时，这种服务器模型还是可以应付的。
           但是随着互联网业务的迅猛发展，繁忙的web服务器每天可能需要处理千万以上的连接，并发服务器的问题在于为每个客户现场fork一个子进程比较消耗cpu时间。
     
    3.预先派生子进程，每个子进程都调用accept，accept无上锁保护
         缺点：
    • 服务器必须在启动的时候判断需要预先派生多少子进程
    • 惊群现象(一个连接到来唤醒所有监听进程)，不过较新版本的linux貌似修正了这个问题
         优点：无须引入父进程执行fork的开销就能处理新到的客户
    4.预先派生子进程，以文件锁的方式保护accept
           本模型与3的区别仅仅是对accept(listenfd)使用了文件锁。
           这种模型是为了解决以库函数的形式实现的accept不能在多个进程中引用同一个监听套接口的问题(源自BSD的unix，在内核中实现的accept可以引用)。使用文件锁保证了每个连接到来，只有一个进程阻塞在accept调用上。对于已经在内核中实现了accept的系统来说，这种模型至少增加了加锁解锁的开销，所以相对于第3种模型性能较低(特别是在消除了惊群问题的系统上)
     
    5.预先派生子进程，以线程互斥锁上锁的方式保护accept
           典型代码：
    [cpp] view plain copy
     
    1. static pthread_mutex_t *mptr;  
    2. void  
    3. my_lock_init(char *pathname)  
    4. {  
    5. int fd;  
    6. pthread_mutexattr_t mattr;  
    7. //因为是相关进程所以可以使用/dev/zero设备创建共享内存  
    8. //优势是调用mmap创建共享存储区之前无需一个实际的文件  
    9. //映射/dev/zero自动创建一个指定长度的映射区  
    10. fd = open("/dev/zero", O_RDWR, 0,);  
    11. // 将mptr映射到共享存储区  
    12. mptr = mmap(0, sizeof(pthread_mutex_t), PORT_READ | PORT_WRITE, MAP_SHARED, fd, 0);  
    13. close(fd);  
    14. pthread_mutexattr_init(&mattr);  
    15. pthread_mutexattr_setpshared(&mptr, PTHREAD_PROCESS_SHARED);  
    16. pthread_mutex_init(mptr, &mattr);  
    17. }  
    18.   
    19. void  
    20. my_lock_wait()  
    21. {  
    22. pthread_mutex_lock(mptr);  
    23. }  
    24.   
    25. void  
    26. my_lock_release()  
    27. {  
    28. pthread_mutex_unlock(mptr);  
    29. }  
    30.   
    31. int  
    32. main(int argc, char **argv)  
    33. {  
    34. //init socket and address  
    35. my_lock_init(pathname);  
    36. for(i = 0; i < nchildren; ++i)  
    37. {  
    38. pids[i] = child_make(i, listenfd, addrlen);  
    39. }  
    40.   
    41. for(;;)  
    42. pause();  
    43. }  
    44.   
    45. pid_t  
    46. child_make(int i, int listenfd, int addrlen)  
    47. {  
    48. pid_t pid;  
    49.   
    50. if((pid = fork) > 0)  
    51. return pid;  
    52.   
    53. child_main(i, listenfd, addrlen);  
    54. }  
    55.   
    56. void  
    57. child_main()  
    58. {  
    59. for(;;)  
    60. {  
    61. my_lock_wait();  
    62. connfd = accept(listenfd, chiladdr, &clilen);  
    63. my_lock_release();  
    64. web_child(connfd);  
    65. close(connfd);  
    66. }  
    67. }  
           这种模型在模型4上做出了进一步的改进，由于以文件锁的方式实现保护会涉及文件系统，这样可能比较耗时，所以改进的办法是以pthread mutex互斥量代替文件锁。使用线程上锁保护accept不仅适用于同一进程内各线程上锁，也适用于不同进程间上锁在多进程环境下使用线程互斥锁实现同步有两点要求：
    1.互斥锁必须放在由所有进程共享的内存区
    2.必须告知线程库这是在不同的进程间共享的互斥锁
           注意：目前很火的高性能web服务器的代表nginx就是采用的这种模型，网络上对nginx的研究很多。
     
    6.预先派生子进程，由父进程向子进程传递套接口描述字
         优势：不需要对accept上锁保护
         劣势：
    • 编码复杂—父进程必须跟踪子进程的忙闲状态，以便给空闲子进程传递新的套接口。在前述的预先派生子进程的例子中，父进程无需关心由哪一个子进程接收一个客户连接，操作系统会根据调度算法处理这些细节。采用这种模型的结果是这些进程无法均衡的处理连接。
    • 父进程通过字节流管道把描述子传递到各个子进程，并且各个子进程通过字节流管道写回单个字节，比起无论是使用共享内存区中的互斥锁还是使用文件锁实施的上锁和解锁都更费时。
     
    7.并发服务器，为每个客户请求创建一个线程
           典型代码：
    [cpp] view plain copy
     
    1. for(;;)  
    2. {  
    3. connfd = accept(listenfd, cliaddr, &clilen,);  
    4. pthread_create(&tid, NULL, &doit, (void *)connfd);  
    5. }  
    6.   
    7. void *  
    8. doit(void *arg)  
    9. {  
    10. pthread_detach(pthread_self());  
    11. web_child((int)arg);  
    12. close((int)arg)  
    13. return (NULL);  
    14. }  
           优点：编码简单。
           缺点：现场为每个连接创建线程相对于预先派生线程池来说比较耗时。
     
    8.预先创建线程，以互斥锁上锁方式保护accept
        优势：
    • 编程简介，易于理解
    • 线程池的方式避免了现场创建线程的开销
    • OS线程调度算法保证了线程负载的均衡性
           这就是leader-follower模式一个线程等待连接到来，其他线程休眠；新连接到来后leader去处理连接，释放listenfd,其他线程竞抢监听套接口listenfd(可能有惊群的问题)。leader在处理完连接以后成为follower。
     
    9.预先创建线程，由主线程调用accept，并把每个客户连接传递给线程池中某个可用线程
           劣势：相对于模型8，该模型不仅需要使用pthread mutex额外还需要使用pthread cond。
  • 相关阅读:
    【学习总结】iOS 的机制
    【刷题】面筋-游戏测试-对二次元游戏的认识
    【JAVA】Mac下查看已安装的jdk版本及其安装目录
    【JAVA】MacBook安装Java环境及eclipse
    【学习总结】哈希表：哈希函数构造；哈希表解决地址冲突的方法
    【刷题】面筋-JAVA-hashmap和hashtable
    【刷题】面筋-测开-软件测试的生命周期
    【学习总结】jupyter notebook中以Markdown格式显示文字信息
    【学习总结】n & (n-1)
    【学习总结】IOS系统和Android系统的区别
  • 原文地址：https://www.cnblogs.com/fchy822/p/8995385.html
Copyright © 2011-2022 走看看