echo_server 多进程版本

  1. #include <unistd.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <sys/socket.h>
  5. #include <sys/types.h>
  6. #include <memory.h>
  7. #include <signal.h>
  8. #include <string.h>
  9. #include <errno.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <sys/wait.h>
  13. int sockfd;
  14.  
  15. void sign_handler(int signo)
  16. {
  17.     pid_t pid;
  18.     int stat;
  19.     if(signo==SIGINT)
  20.     {
  21.         printf("echo server close\n");
  22.         close(sockfd);
  23.         exit();
  24.     }
  25.     if(signo==SIGCHLD){
  26.         while((pid=waitpid(-,&stat,WNOHANG))>){
  27.             printf("child %d closed\n",pid);
  28.         }
  29.     }
  30.     return ;
  31. }
  32. void out_fd(int fd)
  33. {
  34.     struct sockaddr_in arr;
  35.     socklen_t len=sizeof(arr);
  36.     if(getpeername(fd,(struct sockaddr*)&arr,&len)<){
  37.         perror("getpeername fail\n");
  38.         exit();
  39.     }
  40.     char ip[];
  41.     memset(&ip,,sizeof(ip));
  42.     inet_ntop(AF_INET,&arr.sin_addr.s_addr,ip,sizeof(ip));
  43.     printf("%s connected\n",ip);
  44. }
  45. void server_do(int fd)
  46. {
  47.     char buffer[BUFSIZ];
  48.     while(){
  49.         printf("ready to read\n");
  50.         memset(buffer,,sizeof(buffer));
  51.         ssize_t size;
  52.         if((size=read(fd,buffer,sizeof(buffer)))<){
  53.             perror("server child read fail\n");
  54.             break;
  55.         }else if(size==){
  56.             break;
  57.         }else{
  58.             printf("number of received bytes=%ld\n",size);
  59.             buffer[size-]='\0';
  60.             printf("%s\n",buffer);
  61.             if(write(fd,buffer,size)<){
  62.                 if(errno==EPIPE){
  63.                     break;
  64.                 }
  65.                 perror("server child write fail\n");
  66.             }
  67.         }
  68.     }
  69. }
  70. int main(int argc,char *argv[])
  71. {
  72.     int fd;
  73.     pid_t pid;
  74.     if(argc<)
  75.     {
  76.         printf("usage:%s <port>",argv[]);
  77.         exit();
  78.     }
  79.     //注册信号
  80.     if(signal(SIGINT,sign_handler)==SIG_ERR){
  81.         perror("signal sigint error\n");
  82.         exit();
  83.     }
  84.     if(signal(SIGCHLD,sign_handler)==SIG_ERR){
  85.         perror("signal sigint error\n");
  86.         exit();
  87.     }
  88.     /*create socket*/
  89.     sockfd=socket(AF_INET,SOCK_STREAM,);
  90.     if(sockfd<){
  91.         perror("socket create fail\n");
  92.         exit();
  93.     }
  94.     /*bind socket*/
  95.     struct sockaddr_in serveraddr;
  96.     serveraddr.sin_family=AF_INET;
  97.     serveraddr.sin_port=htons(atoi(argv[]));
  98.     serveraddr.sin_addr.s_addr=INADDR_ANY;
  99.     if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<){
  100.         perror("socket bind fail\n");
  101.         exit();
  102.     }
  103.     if(listen(sockfd,)<){
  104.         perror("socket listen fail\n");
  105.         exit();
  106.     }
  107.     /*accept*/
  108.     while(){
  109.         if((fd=accept(sockfd,NULL,NULL))<){
  110.             if(errno==EINTR){
  111.                 continue;
  112.             }
  113.             perror("socket accept fail\n");
  114.         }
  115.         pid_t pid=fork();
  116.         if((pid=fork())<){
  117.             perror("fork fail\n");
  118.             continue;
  119.         }else if(pid==){
  120.             close(sockfd);
  121.             out_fd(fd);
  122.             server_do(fd);
  123.             exit();
  124.         }
  125.         close(fd);
  126.     }
  127.     return ;
  128. }

echo_client

  1. #include <unistd.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <sys/socket.h>
  5. #include <memory.h>
  6. #include <signal.h>
  7. #include <string.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  1. int sockfd;
  1. void cli_do(int sockfd)
    {
  2.  
  3. /*双向通信*/    char buffer[BUFSIZ];
  1.     char *promat=">";
  2.     size_t size;
  3.     while(1){
  4.         memset(buffer,0,sizeof(buffer));
  5.         write(STDOUT_FILENO,promat,1);
  6.         if((size=read(STDIN_FILENO,buffer,sizeof(buffer))>0){
  7.             if(size<0) continue;
  8.             buffer[size-1]='\0';
            }else if(size==0){
    　　　　　　　continue;
    　　　　 }
  9.         if(write(sockfd,buffer,size)>0){
  10.             if(read(sockfd,buffer,sizeof(buffer))>0){
  11.                 printf("%s\n",buffer);
  12.             }
  13.         }
  14.     }
  1. }
  2. int main(int argc,char *argv[])
  3. {
  4.     if(argc<){
  5.         printf("usage:%s <ip><port>",argv[]);
  6.         exit();
  7.     }
  8.     /*create socket*/
  9.     sockfd=socket(AF_INET,SOCK_STREAM,);
  10.     if(sockfd<){
  11.         perror("socket create fail\n");
  12.     }
  13.     struct sockaddr_in serveraddr;
  14.     serveraddr.sin_family=AF_INET;
  15.     serveraddr.sin_port=htons(atoi(argv[]));
  16.     inet_pton(AF_INET,argv[],&serveraddr.sin_addr.s_addr);
  17.     if(connect(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<){
  18.         perror("server connect fail\n");
  19.         exit();
  20.     }
  21.     cli_do(sockfd);
  22.     close(sockfd);
  23.     return ;
  24. }

 echo客户机改进：

客户机read阻塞与stdin时，如果此时服务器断开连接,服务器给客户机发送一个FIN,但是客户机此时阻塞与标准输入，它将看不到这个EOF

所以进程需要一个预先告知内核能力，使得内核一旦发现进程指定一个或者多个I/O条件就绪 ，它就通知进程，这个能力称为I/O多路复用

所以客户端cli_do改用select方式

cli_do修订

  1. void cli_do(int sockfd)
  2. {
  3.     char buffer[BUFSIZ];
  4.     char *promat=">";
  5.     size_t size;
  6.     fd_set rset;
  7.     FD_ZERO(&rset);
  8.     while(){
  9.         //select系统调用设置
  10.         FD_SET(sockfd,&rset);
  11.         FD_SET(STDIN_FILENO,&rset);
  12.         //设置select就绪事件
  13.         if(select(sockfd+,&rset,NULL,NULL,NULL)<){
  14.             perror("select close\n");
  15.             break;
  16.         }
  17.         if(FD_ISSET(STDIN_FILENO,&rset)){/*input is readable*/
  18.             if((size=read(STDIN_FILENO,buffer,sizeof(buffer))>0{
  19.                buffer[size-]='\0';
    　　　　　　  }
                write(sockfd,buffer,size)
  20.         }
  21.         if(FD_ISSET(sockfd,&rset)){/*socket is readable*/
  22.             if((size=read(sockfd,buffer,sizeof(buffer))==0){//服务端发送FIN过来
  23.                 perror("server connect close\n");
  24.                 break;
  25.             }else{
  26.                 printf("%s\n",buffer);
  27.             }
  28.         }
  29.     }
  30. }

echo客户端改进：

这种客户端--服务端   应-答  模式全双工管道数据并没有写满，存在空间的极大浪费

我们改用 批量输入-批量应答  模式

使用select 和shutdown 函数，前者能接收到服务器关闭时的通知，后者运行我们批量输入

cli_do修订

  1. void cli_do(int sockfd)
  2. {
  3.     int stdineof;
  4.     char buffer[BUFSIZ];
  5.     char *promat=">";
  6.     size_t size;
  7.     fd_set rset;
  8.  
  9.     FD_ZERO(&rset);
  10.     stdineof=;
  11.     while(){
  12.         write(STDOUT_FILENO,promat,);
  13.         //select系统调用设置
  14.         FD_SET(sockfd,&rset);
  15.         if(stdineof==) FD_SET(STDIN_FILENO,&rset);
  16.         //设置select就绪事件
  17.         if(select(sockfd+,&rset,NULL,NULL,NULL)<){
  18.             perror("select close\n");
  19.             break;
  20.         }
  21.         if(FD_ISSET(STDIN_FILENO,&rset)){/*input is readable*/
  22.             if((size=read(STDIN_FILENO,buffer,sizeof(buffer)))==){
  23.                 stdineof=;
  24.                 shutdown(sockfd,SHUT_WR);/*send FIN*/
  25.                 FD_CLR(STDIN_FILENO,&rset);
  26.                 continue;
  27.             }
  28.             buffer[size-]='\0';
  29.             write(sockfd,buffer,size);
  30.         }
  31.         if(FD_ISSET(sockfd,&rset)){/*socket is readable*/
  32.             if((size=read(sockfd,buffer,sizeof(buffer)))==){
  33.                 if(stdineof==){
  34.                     return;
  35.                 }else{
  36.                     perror("server terminated prematurely\n");
    　　　　　　　　　　　 break;
  37.                 }
  38.             }
  39.             printf("%s\n",buffer);
  40.         }
  41.     }
  42. }

 使用I/O复用模型  单进程 select 就绪事件监听描述符集 修改echo_server

echo_server 修订版

  1. #include <unistd.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <sys/socket.h>
  5. #include <sys/types.h>
  6. #include <memory.h>
  7. #include <signal.h>
  8. #include <string.h>
  9. #include <errno.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <sys/wait.h>
  13. #include <sys/select.h>
  14. int sockfd;
  15.  
  16. void sign_handler(int signo)
  17. {
  18.     pid_t pid;
  19.     int stat;
  20.     if(signo==SIGINT)
  21.     {
  22.         printf("echo server close\n");
  23.         close(sockfd);
  24.         exit();
  25.     }
  26.     if(signo==SIGCHLD){
  27.         printf("client close\n");
  28.         wait();
  29.     }
  30.     return ;
  31. }
  32. void out_fd(int fd)
  33. {
  34.     struct sockaddr_in arr;
  35.     socklen_t len=sizeof(arr);
  36.     if(getpeername(fd,(struct sockaddr*)&arr,&len)<){
  37.         perror("getpeername fail\n");
  38.         exit();
  39.     }
  40.     char ip[];
  41.     memset(&ip,,sizeof(ip));
  42.     inet_ntop(AF_INET,&arr.sin_addr.s_addr,ip,sizeof(ip));
  43.     printf("%s connected\n",ip);
  44. }
  45.  
  46. int main(int argc,char *argv[])
  47. {
  48.     int fd;
  49.     pid_t pid;
  50.     if(argc<)
  51.     {
  52.         printf("usage:%s <port>",argv[]);
  53.         exit();
  54.     }
  55.     //注册信号
  56.     if(signal(SIGINT,sign_handler)==SIG_ERR){
  57.         perror("signal sigint error\n");
  58.         exit();
  59.     }
  60.     if(signal(SIGCHLD,sign_handler)==SIG_ERR){
  61.         perror("signal sigint error\n");
  62.         exit();
  63.     }
  64.     /*create socket*/
  65.     sockfd=socket(AF_INET,SOCK_STREAM,);
  66.     if(sockfd<){
  67.         perror("socket create fail\n");
  68.         exit();
  69.     }
  70.     /*bind socket*/
  71.     struct sockaddr_in serveraddr,cliaddr;
  72.     serveraddr.sin_family=AF_INET;
  73.     serveraddr.sin_port=htons(atoi(argv[]));
  74.     serveraddr.sin_addr.s_addr=INADDR_ANY;
  75.     if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<){
  76.         perror("socket bind fail\n");
  77.         exit();
  78.     }
  79.     if(listen(sockfd,)<){
  80.         perror("socket listen fail\n");
  81.         exit();
  82.     }
  83.     /*accept*/
  84.     int i,maxfd,maxi,connfd,clientfd;
  85.     int nready,client[FD_SETSIZE];
  86.     ssize_t size;
  87.     fd_set rset,allset;
  88.     char buffer[BUFSIZ];
  89.     socklen_t clien;
  90.  
  91.     maxfd=sockfd;
  92.     maxi=-;/*index into client[] array*/
  93.     for(i=;i<FD_SETSIZE;i++){
  94.         client[i]=-;
  95.     }
  96.     FD_ZERO(&allset);
  97.     FD_SET(sockfd,&allset);
  98.     for(;;){
  99.         rset=allset;
  100.         nready=select(maxfd+,&rset,NULL,NULL,NULL);
  101.  
  102.         if(FD_ISSET(sockfd,&rset)){/*new client connection*/
  103.             clien=sizeof(cliaddr);
  104.             if((connfd=accept(sockfd,(struct sockaddr*)&cliaddr,&clien))>){
  105.                 out_fd(connfd);
  106.             }
  107.             for(i=;i<FD_SETSIZE;i++){
  108.                 if(client[i]<){
  109.                     client[i]=connfd;
  110.                     break;
  111.                 }
  112.             }
  113.             if(i==FD_SETSIZE){
  114.                 perror("too many clients\n");
  115.             }
  116.             FD_SET(connfd,&allset);//添加新的监听就绪事件
  117.             if(connfd>maxfd) maxfd=connfd;
  118.             if(i>maxi) maxi=i;
  119.             if(--nready<=) continue;
  120.         }
  121.         for(i=;i<=maxi;i++){/*check all clients for data*/
  122.             if((clientfd=client[i])<) continue;
  123.             if(FD_ISSET(clientfd,&rset)){
  124.                 printf("ready to read\n");
  125.                 if((size=read(clientfd,buffer,sizeof(buffer)))==){//接受到EOF，client已经关闭
  126.                     close(clientfd);
  127.                     FD_CLR(clientfd,&allset);
  128.                     client[i]=-;
  129.                 }else{
  130.                     printf("%s\n",buffer);
  131.                     write(clientfd,buffer,size);
  132.                     if(--nready<=) break;
  133.                 }
  134.             }
  135.  
  136.         }
  137.     }
  138. }

poll系统调用

  1. void cli_do(int sockfd)
  2. {
  3.     int stdineof;
  4.     char buffer[BUFSIZ];
  5.     char *promat=">";
  6.     size_t size;
  7.     fd_set rset;
  8.  
  9.     FD_ZERO(&rset);
  10.     stdineof=;
  11.     while(){
  12.         write(STDOUT_FILENO,promat,);
  13.         //select系统调用设置
  14.         FD_SET(sockfd,&rset);
  15.         if(stdineof==) FD_SET(STDIN_FILENO,&rset);
  16.         //设置select就绪事件
  17.         if(select(sockfd+,&rset,NULL,NULL,NULL)<){
  18.             perror("select close\n");
  19.             break;
  20.         }
  21.         if(FD_ISSET(STDIN_FILENO,&rset)){/*input is readable*/
  22.             if((size=read(STDIN_FILENO,buffer,sizeof(buffer)))==){
  23.                 stdineof=;
  24.                 shutdown(sockfd,SHUT_WR);/*send FIN*/
  25.                 FD_CLR(STDIN_FILENO,&rset);
  26.                 continue;
  27.             }
  28.             buffer[size-]='\0';
  29.             write(sockfd,buffer,size);
  30.         }
  31.         if(FD_ISSET(sockfd,&rset)){/*socket is readable*/
  32.             if((size=read(sockfd,buffer,sizeof(buffer)))==){
  33.                 if(stdineof==){
  34.                     return;
  35.                 }else{
  36.                     perror("server terminated prematurely\n");
  37.                     break;
  38.                 }
  39.             }
  40.             printf("%s\n",buffer);
  41.         }
  42.     }
  43. }

echo_server

  1. #include <unistd.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <sys/socket.h>
  5. #include <sys/types.h>
  6. #include <memory.h>
  7. #include <signal.h>
  8. #include <string.h>
  9. #include <errno.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <sys/wait.h>
  13. #include <sys/select.h>
  14. #include <poll.h>
  15.  
  16. int sockfd;
  17.  
  18. void sign_handler(int signo)
  19. {
  20.     pid_t pid;
  21.     int stat;
  22.     if(signo==SIGINT)
  23.     {
  24.         printf("echo server close\n");
  25.         close(sockfd);
  26.         exit();
  27.     }
  28.     if(signo==SIGCHLD){
  29.         printf("client close\n");
  30.         wait();
  31.     }
  32.     return;
  33. }
  34. void out_fd(int fd)
  35. {
  36.     struct sockaddr_in arr;
  37.     socklen_t len=sizeof(arr);
  38.     if(getpeername(fd,(struct sockaddr*)&arr,&len)<){
  39.         perror("getpeername fail\n");
  40.         exit();
  41.     }
  42.     char ip[];
  43.  
  44.     memset(&ip,,sizeof(ip));
  45.     inet_ntop(AF_INET,&arr.sin_addr.s_addr,ip,sizeof(ip));
  46.     printf("%s connected\n",ip);
  47. }
  48.  
  49. int main(int argc,char *argv[])
  50. {
  51.     printf("tsest");
  52.  
  53.     if(argc<)
  54.     {
  55.         printf("usage:%s <port>",argv[]);
  56.         exit();
  57.     }
  58.     //注册信号
  59.     if(signal(SIGINT,sign_handler)==SIG_ERR){
  60.         perror("signal sigint error\n");
  61.         exit();
  62.     }
  63.     if(signal(SIGCHLD,sign_handler)==SIG_ERR){
  64.         perror("signal sigint error\n");
  65.         exit();
  66.     }
  67.     /*create socket*/
  68.     sockfd=socket(AF_INET,SOCK_STREAM,);
  69.     if(sockfd<){
  70.         perror("socket create fail\n");
  71.         exit();
  72.     }
  73.     /*bind socket*/
  74.     struct sockaddr_in serveraddr,cliaddr;
  75.     serveraddr.sin_family=AF_INET;
  76.     serveraddr.sin_port=htons(atoi(argv[]));
  77.     serveraddr.sin_addr.s_addr=INADDR_ANY;
  78.     if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<){
  79.         perror("socket bind fail\n");
  80.         exit();
  81.     }
  82.     if(listen(sockfd,)<){
  83.         perror("socket listen fail\n");
  84.         exit();
  85.     }
  86.     /*poll系统调用*/
  87.     int i,maxfd,maxi,connfd,clientfd,nready,open_max;
  88.     ssize_t size;
  89.     char buffer[BUFSIZ];
  90.     socklen_t clien;
  91.     open_max=sysconf(_SC_OPEN_MAX);
  92.  
  93.     struct pollfd client[open_max];
  94.     client[].fd=sockfd;
  95.     client[].events=POLLRDNORM;
  96.     for(i=;i<open_max;i++) client[i].fd=-;
  97.     maxi=;
  98.  
  99.     for(;;){
  100.         nready=poll(client,maxi+,);
  101.  
  102.         if(client[].revents & POLLRDNORM){/*new client connection*/
  103.             printf("werwerew");
  104.             break;
  105.             clien=sizeof(cliaddr);
  106.             if((connfd=accept(sockfd,(struct sockaddr*)&cliaddr,&clien))>) out_fd(connfd);
  107.  
  108.             for(i=;i<open_max;i++){
  109.                 if(client[i].fd<){
  110.                     client[i].fd=connfd;
  111.                     break;
  112.                 }
  113.             }
  114.             if(i==open_max) perror("too many clients\n");
  115.             client[i].events=POLLRDNORM;//添加新的监听就绪事件
  116.             if(i>maxi) maxi=i;
  117.             if(--nready<=) continue;
  118.         }
  119.         for(i=;i<=maxi;i++){/*check all clients for data*/
  120.             if((clientfd=client[i].fd)<) continue;
  121.             if(client[i].revents&(POLLRDNORM|POLLERR)){
  122.                 printf("ready to read\n");
  123.                 break;
  124.                 if((size=read(clientfd,buffer,sizeof(buffer)))==){//接受到EOF，client已经关闭
  125.                     close(clientfd);
  126.                     client[i].fd=-;
  127.                 }else{
  128.                     printf("%s\n",buffer);
  129.                     write(clientfd,buffer,size);
  130.                     if(--nready<=) break;
  131.                 }
  132.             }
  133.  
  134.         }
  135.     }
  136.     return ;
  137. }

linux网络编程echo多进程服务器的更多相关文章

  1. Linux网络编程echo多线程服务器

    echo_server服务器多线程版本 #include <unistd.h> #include <stdlib.h> #include <stdio.h> #in ...

  2. Linux网络编程——tcp并发服务器（poll实现）

    想详细彻底地了解poll或看懂下面的代码请参考<Linux网络编程——I/O复用之poll函数> 代码: #include <string.h> #include <st ...

  3. Linux 网络编程: echo Service

    前言 大病初愈,感谢某人的陪伴,感谢王乐庆同学和赵攀同学的细心照顾.原以为过了第八周就不忙了,却没想到还有明天的党章考试.还是写代码比背党章有意思~趁着服务器还没过期,赶紧把 echo 完成了.关于错 ...

  4. Linux网络编程：客户端/服务器的简单实现

    一. Socket的基本知识 1. socket功能 Socket层次 Socket实质上提供了进程通信的端点,进程通信之前,双方必须首先各自创建一个端点,否则是没有办法建立联系并相互通信的. 每一个 ...

  5. 服务器编程入门（4）Linux网络编程基础API

      问题聚焦:     这节介绍的不仅是网络编程的几个API     更重要的是,探讨了Linux网络编程基础API与内核中TCP/IP协议族之间的关系.     这节主要介绍三个方面的内容:套接字( ...

  6. Linux 高性能服务器编程——Linux网络编程基础API

    问题聚焦:     这节介绍的不仅是网络编程的几个API     更重要的是,探讨了Linux网络编程基础API与内核中TCP/IP协议族之间的关系.     这节主要介绍三个方面的内容:套接字(so ...

  7. linux高性能服务器编程 (五) --Linux网络编程基础api

    第五章 Linux网络编程基础api 1.主机字节序和网络字节序 字节序是指整数在内存中保存的顺序.字节序分为大端字节序.小端字节序. 大端字节序:一个整数的高位字节数据存放在内存的低地址处.低位字节 ...

  8. Linux网络编程服务器模型选择之并发服务器（上）

    与循环服务器的串行处理不同,并发服务器对服务请求并发处理.循环服务器只能够一个一个的处理客户端的请求,显然效率很低.并发服务器通过建立多个子进程来实现对请求的并发处理.并发服务器的一个难点是如何确定子 ...

  9. Linux网络编程入门 (转载)

    (一)Linux网络编程--网络知识介绍 Linux网络编程--网络知识介绍客户端和服务端         网络程序和普通的程序有一个最大的区别是网络程序是由两个部分组成的--客户端和服务器端. 客户 ...

随机推荐

  1. group by应用

    注意: having是对分组后的数据进行第二次筛选或者过滤,也就是说没有group by就没having where之后不能有聚合函数 查询每个年级的总学时数,并按照升序排列select GradeI ...

  2. 【POJ3468】【zkw线段树】A Simple Problem with Integers

    Description You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. On ...

  3. php文件加锁 lock_sh ,lock_ex

    文件锁有两种:共享锁和排他锁,也就是读锁(LOCK_SH)和写锁(LOCK_EX) 文件的锁一般这么使用: $fp = fopen("filename", "a" ...

  4. WPF自定义DataGrid分页控件

    新建Custom Control,名:PagingDataGrid 打开工程下面的Themes\Generic.xaml xaml里面代码替换如下 <Style x:Key="{x:T ...

  5. Node 之 Express 学习笔记 第二篇 Express 4x 骨架详解

    周末,没事就来公司加班继续研究一下Express ,这也许也是单身狗的生活吧. 1.目录结构: bin, 存放启动项目的脚本文件 node_modules, 项目所有依赖的库,以及存放 package ...

  6. JQUERY1.9学习笔记 之属性选择器(二) 包含选择器

    jQuery("[attribute*='value']") 描述:选择所有与给定值匹配的属性值的标签. 例:找出所有name属性包含"man"的input标签 ...

  7. Day12 线程池、RabbitMQ和SQLAlchemy

    1.with实现上下文管理 #!/usr/bin/env python# -*- coding: utf-8 -*-# Author: wanghuafeng #with实现上下文管理import c ...

  8. 理解Python的*args, **kwargs

    1 # coding=utf-8 2 def speak(*args, **kwargs): 3 print args, kwargs 4 5 6 a = 1 7 b = 2 8 c = 3 9 sp ...

  9. bzoj3864: Hero meet devil

    Description There is an old country and the king fell in love with a devil. The devil always asks th ...

  10. WINDOWS下的SALT-MINION安装流水图

    简单的下一步下一步, 没多少说的,可以在安装的时候设置MASTER和MINION的东东.. 不多说,上图: