CodeHeng
CodeHeng

epoll,select,poll单线程服务端示例

1、关于字节排序    网际协议采用大端字节序，来传输多字节整数。    系统提供了转换的宏定义，如果主机与网际协议相同，则宏定义为空。

2、客户端    socket -> connect(阻塞,三次握手)-> rcv

3、服务器端    socket -> bind -> listen -> accept(阻塞,三次握手)-> send4、函数介绍    

     a..socket        

          1)函数原型 int socket(int family, int type, int protocol)        

          2)参数：                family: 协议族AF_INET,IPv4协议 ...            type : type 套接字类型SOCK_STREAM 字节流套接字            protocol: IPPROCO_TCP IPPROCO_UDP                     IPPROCO_SCTP       

          3)返回值            成功:返回套接字符            错误:返回INVALID_SOCKET(-1)        

         4)示例

[cpp] view plain copy print ?
  1. #include    
  2. #include    
  3. #include    
  4. int main()  
  5. {  
  6.     int socketfd;  
  7.     struct sockaddr_in servaddr;  
  8.   
  9.     if((socketfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
  10.     {  
  11.         return -1;  
  12.     }  
  13. }  
#include 
#include 
#include 
int main()
{
    int socketfd;
    struct sockaddr_in servaddr;

    if((socketfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        return -1;
    }
}


        
    b..connect
        1)函数原型 int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen)
        2)参数：    
            sockfd: socket 函数返回的套接字描述符
            servaddr : 服务器的IP和端口
            addrlen: 长度(sizeof(servaddr))
        3)返回值
            成功:0
            错误:返回INVALID_SOCKET(-1)
        4)示例
[cpp] view plain copy print ?
  1. #include    
  2. #include    
  3. #include    
  4. #include    
  5. #include    
  6.   
  7. int main()  
  8. {  
  9.     int socketfd;  
  10.     struct sockaddr_in servaddr;  
  11.   
  12.     if((socketfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
  13.     {  
  14.         printf("socket error\n");  
  15.         return -1;  
  16.     }  
  17.   
  18.     bzero(&servaddr, sizeof(servaddr));  
  19.   
  20.     servaddr.sin_addr.s_addr = inet_addr("192.168.0.218");  
  21.     servaddr.sin_family = AF_INET;  
  22.     servaddr.sin_port = htons(55000);  
  23.   
  24.     if(connect(socketfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0)  
  25.     {  
  26.         printf("connect error\n");  
  27.     }  
  28.   
  29.     return 0;  
  30. }  
#include 
#include 
#include 
#include 
#include 

int main()
{
    int socketfd;
    struct sockaddr_in servaddr;

    if((socketfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("socket error\n");
        return -1;
    }

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_addr.s_addr = inet_addr("192.168.0.218");
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(55000);

    if(connect(socketfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0)
    {
        printf("connect error\n");
    }

    return 0;
}

    c..bind
        1)函数原型 int bind(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen)
        2)参数：    
            sockfd: socket 函数返回的套接字描述符
            servaddr : 服务器的IP和端口
            addrlen: 长度(sizeof(servaddr))
        3)返回值
            成功:0
            错误:返回INVALID_SOCKET(-1)
            
    d..listen
        1)函数原型 int listen(int sockfd, int backlog)
        2)参数：    
            sockfd: socket 函数返回的套接字描述符
            backlog : 内核中套接字排队的最大个数
        3)返回值
            成功:0
            错误:返回INVALID_SOCKET
                
    e..accept
        1)函数原型 int accept(int sockfd, const struct sockaddr *servaddr, socklen_t *addrlen)
        2)参数：    
            sockfd: socket 函数返回的套接字描述符


        3)返回值
            servaddr : 客户进程的IP和端口(可设为null)
            addrlen: 长度(sizeof(servaddr))(可设为null)
            成功:从监听套接字返回已连接套接字
            错误:
            如果对客户信息不感兴趣，后两个参数可以置空。

        4）示例

[cpp] view plain copy print ?
  1. #include    
  2. #include    
  3. #include    
  4. #include    
  5. #include    
  6.   
  7. int main()  
  8. {  
  9.     int count = 0;  
  10.     int listenfd, socketfd;  
  11.     int nread;  
  12.     struct sockaddr_in servaddr;  
  13.     struct timeval timeoutval;  
  14.     char readbuf[256];  
  15.   
  16.     printf("accept started\n");  
  17.   
  18.     //socket       
  19.     if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
  20.     {  
  21.         printf("socket error\n");  
  22.         return -1;  
  23.     }  
  24.   
  25.     bzero(&servaddr, sizeof(servaddr));  
  26.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  27.     servaddr.sin_family = AF_INET;  
  28.     servaddr.sin_port = htons(59000);  
  29.   
  30.     //bind   
  31.     if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)  
  32.     {  
  33.         printf("bind error\n");  
  34.         //return -1;   
  35.     }  
  36.   
  37.     //listen   
  38.     listen(listenfd, 5);  
  39.   
  40.     //accept   
  41.     socketfd = accept(listenfd, NULL, NULL);  
  42.   
  43.   
  44.   
  45.     while(1)  
  46.     {  
  47.         printf("start receive %d...\n", count++);  
  48.         memset(readbuf, sizeof(readbuf), 0);  
  49.   
  50.         nread = recv(socketfd, readbuf, 10, 0);  
  51.         if(nread>0)  
  52.         {  
  53.             readbuf[10] = '\0';  
  54.             printf("receiveed %s, nread = %d\n\n", readbuf, nread);  
  55.         }  
  56.     }  
  57.   
  58.     return 0;  
  59. }  
#include 
#include 
#include 
#include 
#include 

int main()
{
    int count = 0;
    int listenfd, socketfd;
    int nread;
    struct sockaddr_in servaddr;
    struct timeval timeoutval;
    char readbuf[256];

    printf("accept started\n");

    //socket    
    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("socket error\n");
        return -1;
    }

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(59000);

    //bind
    if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
    {
        printf("bind error\n");
        //return -1;
    }

    //listen
    listen(listenfd, 5);

    //accept
    socketfd = accept(listenfd, NULL, NULL);



    while(1)
    {
        printf("start receive %d...\n", count++);
        memset(readbuf, sizeof(readbuf), 0);

        nread = recv(socketfd, readbuf, 10, 0);
        if(nread>0)
        {
            readbuf[10] = '\0';
            printf("receiveed %s, nread = %d\n\n", readbuf, nread);
        }
    }

    return 0;
}

    /**************************************************************
    从 I/O 事件分派机制来看,使用 select()是不合适的,因为它所支持的并发连接数有限(通
    常在 1024 个以内)。如果考虑性能,poll()也是不合适的,尽管它可以支持的较高的 TCP 并发
    数,但是由于其采用“轮询”机制,当并发数较高时,其运行效率相当低,并可能存在 I/O 事
    件分派不均,导致部分 TCP 连接上的 I/O 出现“饥饿”现象。而如果使用 epoll 或 AIO,则没
    有上述问题(早期 Linux 内核的 AIO 技术实现是通过在内核中为每个 I/O 请求创建一个线程来
    实现的,这种实现机制在高并发 TCP 连接的情形下使用其实也有严重的性能问题。但在最新的
    Linux 内核中,AIO 的实现已经得到改进)。
    支持一个进程打开大数目的 socket 描述符(FD)select 最不能忍受的是一个进程所打开的
    FD 是有一定限制的,由 FD_SETSIZE 设置,默认值是 2048。对于那些需要支持的上万连接数目
    的 IM 服务器来说显然太少了。
    这时候你一是可以选择修改这个宏然后重新编译内核,不过资料
    也同时指出这样会带来网络效率的下降,二是可以选择多进程的解决方案(传统的 Apache 方
    案),不过虽然 linux 上面创建进程的代价比较小,但仍旧是不可忽视的,加上进程间数据同步
    远比不上线程间同步的高效,所以也不是一种完美的方案。不过 epoll 则没有这个限制,它所
    支持的 FD 上限是最大可以打开文件的数目,这个数字一般远大于 2048,举个例子,在 1GB 内存
    的机器上大约是 10 万左右,具体数目可以 cat /proc/sys/fs/file-max 察看,一般来说这个数
    目和系统内存关系很大。
    ******************************************************************/        
5. select函数
    1)函数原型 int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout);
    2)参数：    
        sockfd: socket 函数返回的套接字描述符
        readfds : 读描述符集合
        writefds: 写描述符集合
        errorfds: 错误描述符集合
        timeout:  超时
    3)返回值
        成功:返回值 0:无 >0:描述符就绪的总位数
        错误:返回INVALID_SOCKET(-1)
    4）包含头文件: include include
    5）示例
[cpp] view plain copy print ?
  1. /* 实现功能：通过select处理多个socket 
  2.  * 监听一个端口,监听到有链接时,添加到select的w. 
  3.  */  
  4. #include "select.h"   
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11.   
  12. typedef struct _CLIENT{  
  13.     int fd;  
  14.     struct sockaddr_in addr; /* client's address information */  
  15. } CLIENT;  
  16.   
  17. #define MYPORT 59000   
  18.   
  19. //最多处理的connect   
  20. #define BACKLOG 5   
  21.   
  22. //最多处理的connect   
  23. CLIENT client[BACKLOG];  
  24.   
  25. //当前的连接数   
  26. int currentClient = 0;   
  27.   
  28. //数据接受 buf   
  29. #define REVLEN 10   
  30. char recvBuf[REVLEN];  
  31. //显示当前的connection   
  32. void showClient();  
  33.   
  34. int main()  
  35. {  
  36.     int i, ret, sinSize;  
  37.     int recvLen = 0;  
  38.     fd_set readfds, writefds;  
  39.     int sockListen, sockSvr, sockMax;  
  40.     struct timeval timeout;  
  41.     struct sockaddr_in server_addr;  
  42.     struct sockaddr_in client_addr;  
  43.   
  44.     for(i=0; i
  45.     {  
  46.         client[i].fd = -1;  
  47.     }  
  48.   
  49.     //socket   
  50.     if((sockListen=socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  51.     {  
  52.         printf("socket error\n");  
  53.         return -1;  
  54.     }  
  55.   
  56.     bzero(&server_addr, sizeof(server_addr));  
  57.     server_addr.sin_family  =  AF_INET;  
  58.     server_addr.sin_port = htons(MYPORT);  
  59.     server_addr.sin_addr.s_addr  =  htonl(INADDR_ANY);   
  60.   
  61.     //bind   
  62.     if(bind(sockListen, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)  
  63.     {  
  64.         printf("bind error\n");  
  65.         return -1;  
  66.     }  
  67.   
  68.     //listen   
  69.     if(listen(sockListen, 5) < 0)  
  70.     {  
  71.         printf("listen error\n");  
  72.         return -1;  
  73.     }  
  74.   
  75.     for(i=0; i
  76.     {  
  77.         client[i].fd = -1;  
  78.     }  
  79.   
  80.     //select   
  81.     while(1)  
  82.     {  
  83.         FD_ZERO(&readfds);  
  84.         FD_SET(sockListen, &readfds);  
  85.         sockMax = sockListen;  
  86.       
  87.         //加入client   
  88.         for(i=0; i
  89.         {  
  90.             if(client[i].fd >0)  
  91.             {  
  92.                 FD_SET(client[i].fd, &readfds);  
  93.                 if(sockMax
  94.                     sockMax = client[i].fd;  
  95.             }  
  96.         }  
  97.           
  98.         timeout.tv_sec=3;                  
  99.         timeout.tv_usec=0;  
  100.         //select   
  101.         ret = select((int)sockMax+1, &readfds, NULL, NULL, &timeout);  
  102.         if(ret < 0)  
  103.         {  
  104.             printf("select error\n");  
  105.             break;  
  106.         }  
  107.         else if(ret == 0)  
  108.         {  
  109.             printf("timeout ...\n");  
  110.             continue;  
  111.         }  
  112.         printf("test111\n");  
  113.       
  114.         //读取数据   
  115.         for(i=0; i
  116.         {  
  117.             if(client[i].fd>0 && FD_ISSET(client[i].fd, &readfds))  
  118.             {  
  119.                 if(recvLen != REVLEN)  
  120.                 {  
  121.                     while(1)  
  122.                     {  
  123.                         //recv数据   
  124.                         ret = recv(client[i].fd, (char *)recvBuf+recvLen, REVLEN-recvLen, 0);  
  125.                         if(ret == 0)  
  126.                         {  
  127.                             client[i].fd = -1;  
  128.                             recvLen = 0;  
  129.                             break;  
  130.                         }  
  131.                         else if(ret < 0)  
  132.                         {  
  133.                             client[i].fd = -1;  
  134.                             recvLen = 0;  
  135.                             break;  
  136.                         }  
  137.                         //数据接受正常   
  138.                         recvLen = recvLen+ret;  
  139.                         if(recvLen
  140.                         {  
  141.                             continue;  
  142.                         }  
  143.                         else  
  144.                         {  
  145.                             //数据接受完毕   
  146.                             printf("%s, buf = %s\n", inet_ntoa(client[i].addr.sin_addr) , recvBuf);  
  147.                             //close(client[i].fd);   
  148.                             //client[i].fd = -1;   
  149.                             recvLen = 0;  
  150.                             break;  
  151.                         }  
  152.                     }  
  153.                 }  
  154.             }  
  155.         }  
  156.       
  157.         //如果可读   
  158.         if(FD_ISSET(sockListen, &readfds))  
  159.         {  
  160.             printf("isset\n");  
  161.             sockSvr = accept(sockListen, NULL, NULL);//(struct sockaddr*)&client_addr   
  162.           
  163.             if(sockSvr == -1)  
  164.             {  
  165.                 printf("accpet error\n");  
  166.             }  
  167.             else  
  168.             {  
  169.                 currentClient++;  
  170.             }  
  171.           
  172.             for(i=0; i
  173.             {  
  174.                 if(client[i].fd < 0)  
  175.                 {  
  176.                     client[i].fd = sockSvr;  
  177.                     client[i].addr = client_addr;  
  178.                     printf("You got a connection from %s \n",inet_ntoa(client[i].addr.sin_addr) );  
  179.                     break;  
  180.                 }  
  181.             }  
  182.             //close(sockListen);   
  183.         }  
  184.     }  
  185.   
  186.     printf("test\n");  
  187.     return 0;  
  188. }  
  189.   
  190. //显示当前的connection   
  191. void showClient()  
  192. {  
  193.     int i;  
  194.     printf("client count = %d\n", currentClient);  
  195.   
  196.     for(i=0; i
  197.     {  
  198.         printf("[%d] = %d", i, client[i].fd);  
  199.     }  
  200.     printf("\n");  
  201. }  
/* 实现功能：通过select处理多个socket
 * 监听一个端口,监听到有链接时,添加到select的w.
 */
#include "select.h"
#include 
#include 
#include 
#include 
#include 
#include 

typedef struct _CLIENT{
    int fd;
    struct sockaddr_in addr; /* client's address information */
} CLIENT;

#define MYPORT 59000

//最多处理的connect
#define BACKLOG 5

//最多处理的connect
CLIENT client[BACKLOG];

//当前的连接数
int currentClient = 0; 

//数据接受 buf
#define REVLEN 10
char recvBuf[REVLEN];
//显示当前的connection
void showClient();

int main()
{
    int i, ret, sinSize;
    int recvLen = 0;
    fd_set readfds, writefds;
    int sockListen, sockSvr, sockMax;
    struct timeval timeout;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    for(i=0; i0)
            {
                FD_SET(client[i].fd, &readfds);
                if(sockMax0 && FD_ISSET(client[i].fd, &readfds))
            {
                if(recvLen != REVLEN)
                {
                    while(1)
                    {
                        //recv数据
                        ret = recv(client[i].fd, (char *)recvBuf+recvLen, REVLEN-recvLen, 0);
                        if(ret == 0)
                        {
                            client[i].fd = -1;
                            recvLen = 0;
                            break;
                        }
                        else if(ret < 0)
                        {
                            client[i].fd = -1;
                            recvLen = 0;
                            break;
                        }
                        //数据接受正常
                        recvLen = recvLen+ret;
                        if(recvLen

6. poll函数
    1)函数原型 int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout);
    2)参数：    
        sockfd: socket 函数返回的套接字描述符
        readfds : 读描述符集合
        writefds: 写描述符集合
        errorfds: 错误描述符集合
        timeout:  超时
    3)返回值
        成功:返回值 0:无 >0:描述符就绪的总位数
        错误:返回INVALID_SOCKET(-1)
    4）包含头文件: include include

    5) 示例

[cpp] view plain copy print ?
  1. /* 实现功能：通过poll, 处理多个socket 
  2.  * 监听一个端口,监听到有链接时,添加到poll. 
  3.  */  
  4. #include "select.h"   
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11. #include    
  12.   
  13. typedef struct _CLIENT{  
  14.     int fd;  
  15.     struct sockaddr_in addr; /* client's address information */  
  16. } CLIENT;  
  17.   
  18. #define MYPORT 59000   
  19.   
  20. //最多处理的connect   
  21. #define BACKLOG 5   
  22.   
  23. //当前的连接数   
  24. int currentClient = 0;   
  25.   
  26. //数据接受 buf   
  27. #define REVLEN 10   
  28. char recvBuf[REVLEN];  
  29.   
  30. #define OPEN_MAX 1024   
  31.   
  32. int main()  
  33. {  
  34.     int i, ret, sinSize;  
  35.     int recvLen = 0;  
  36.     fd_set readfds, writefds;  
  37.     int sockListen, sockSvr, sockMax;  
  38.     int timeout;  
  39.     struct sockaddr_in server_addr;  
  40.     struct sockaddr_in client_addr;  
  41.   
  42.     struct pollfd clientfd[OPEN_MAX];  
  43.   
  44.   
  45.     //socket   
  46.     if((sockListen=socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  47.     {  
  48.         printf("socket error\n");  
  49.         return -1;  
  50.     }  
  51.   
  52.     bzero(&server_addr, sizeof(server_addr));  
  53.     server_addr.sin_family  =  AF_INET;  
  54.     server_addr.sin_port = htons(MYPORT);  
  55.     server_addr.sin_addr.s_addr  =  htonl(INADDR_ANY);   
  56.   
  57.     //bind   
  58.     if(bind(sockListen, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)  
  59.     {  
  60.         printf("bind error\n");  
  61.         return -1;  
  62.     }  
  63.   
  64.     //listen   
  65.     if(listen(sockListen, 5) < 0)  
  66.     {  
  67.         printf("listen error\n");  
  68.         return -1;  
  69.     }  
  70.   
  71.   
  72.     //clientfd 初始化   
  73.     clientfd[0].fd = sockListen;  
  74.     clientfd[0].events = POLLIN; //POLLRDNORM;   
  75.     sockMax = 0;  
  76.     for(i=1; i
  77.     {  
  78.         clientfd[i].fd = -1;  
  79.     }  
  80.   
  81.     //select   
  82.     while(1)  
  83.     {  
  84.         timeout=3000;                  
  85.         //select   
  86.         ret = poll(clientfd, sockMax+1, timeout);  
  87.       
  88.         if(ret < 0)  
  89.         {  
  90.             printf("select error\n");  
  91.             break;  
  92.         }  
  93.         else if(ret == 0)  
  94.         {  
  95.             printf("timeout ...\n");  
  96.             continue;  
  97.         }  
  98.       
  99.         if (clientfd[0].revents & POLLIN)//POLLRDNORM   
  100.         {  
  101.             sockSvr = accept(sockListen, NULL, NULL);//(struct sockaddr*)&client_addr   
  102.           
  103.             if(sockSvr == -1)  
  104.             {  
  105.                 printf("accpet error\n");  
  106.             }  
  107.             else  
  108.             {  
  109.                 currentClient++;  
  110.             }  
  111.           
  112.             for(i=0; i
  113.             {  
  114.                 if(clientfd[i].fd<0)  
  115.                 {  
  116.                     clientfd[i].fd = sockSvr;  
  117.                     break;  
  118.                 }  
  119.             }  
  120.             if(i==OPEN_MAX)  
  121.             {  
  122.                 printf("too many connects\n");  
  123.                 return -1;  
  124.             }  
  125.             clientfd[i].events = POLLIN;//POLLRDNORM;   
  126.             if(i>sockMax)  
  127.                 sockMax = i;  
  128.         }  
  129.       
  130.         //读取数据   
  131.         for(i=1; i<=sockMax; i++)  
  132.         {  
  133.             if(clientfd[i].fd < 0)  
  134.                 continue;  
  135.           
  136.             if (clientfd[i].revents & (POLLIN | POLLERR))//POLLRDNORM   
  137.             {  
  138.                 if(recvLen != REVLEN)  
  139.                 {  
  140.                     while(1)  
  141.                     {  
  142.                         //recv数据   
  143.                         ret = recv(clientfd[i].fd, (char *)recvBuf+recvLen, REVLEN-recvLen, 0);  
  144.                         if(ret == 0)  
  145.                         {  
  146.                             clientfd[i].fd = -1;  
  147.                             recvLen = 0;  
  148.                             break;  
  149.                         }  
  150.                         else if(ret < 0)  
  151.                         {  
  152.                             clientfd[i].fd = -1;  
  153.                             recvLen = 0;  
  154.                             break;  
  155.                         }  
  156.                         //数据接受正常   
  157.                         recvLen = recvLen+ret;  
  158.                         if(recvLen
  159.                         {  
  160.                             continue;  
  161.                         }  
  162.                         else  
  163.                         {  
  164.                             //数据接受完毕   
  165.                             printf("buf = %s\n",  recvBuf);  
  166.                             //close(client[i].fd);   
  167.                             //client[i].fd = -1;   
  168.                             recvLen = 0;  
  169.                             break;  
  170.                         }  
  171.                     }  
  172.                 }  
  173.             }  
  174.         }  
  175.     }  
  176.   
  177.     return 0;  
  178. }  
/* 实现功能：通过poll, 处理多个socket
 * 监听一个端口,监听到有链接时,添加到poll.
 */
#include "select.h"
#include 
#include 
#include 
#include 
#include 
#include 
#include 

typedef struct _CLIENT{
    int fd;
    struct sockaddr_in addr; /* client's address information */
} CLIENT;

#define MYPORT 59000

//最多处理的connect
#define BACKLOG 5

//当前的连接数
int currentClient = 0; 

//数据接受 buf
#define REVLEN 10
char recvBuf[REVLEN];

#define OPEN_MAX 1024

int main()
{
    int i, ret, sinSize;
    int recvLen = 0;
    fd_set readfds, writefds;
    int sockListen, sockSvr, sockMax;
    int timeout;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    struct pollfd clientfd[OPEN_MAX];


    //socket
    if((sockListen=socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("socket error\n");
        return -1;
    }

    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family  =  AF_INET;
    server_addr.sin_port = htons(MYPORT);
    server_addr.sin_addr.s_addr  =  htonl(INADDR_ANY); 

    //bind
    if(bind(sockListen, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)
    {
        printf("bind error\n");
        return -1;
    }

    //listen
    if(listen(sockListen, 5) < 0)
    {
        printf("listen error\n");
        return -1;
    }


    //clientfd 初始化
    clientfd[0].fd = sockListen;
    clientfd[0].events = POLLIN; //POLLRDNORM;
    sockMax = 0;
    for(i=1; isockMax)
                sockMax = i;
        }
    
        //读取数据
        for(i=1; i<=sockMax; i++)
        {
            if(clientfd[i].fd < 0)
                continue;
        
            if (clientfd[i].revents & (POLLIN | POLLERR))//POLLRDNORM
            {
                if(recvLen != REVLEN)
                {
                    while(1)
                    {
                        //recv数据
                        ret = recv(clientfd[i].fd, (char *)recvBuf+recvLen, REVLEN-recvLen, 0);
                        if(ret == 0)
                        {
                            clientfd[i].fd = -1;
                            recvLen = 0;
                            break;
                        }
                        else if(ret < 0)
                        {
                            clientfd[i].fd = -1;
                            recvLen = 0;
                            break;
                        }
                        //数据接受正常
                        recvLen = recvLen+ret;
                        if(recvLen

6. epoll函数
        2. 常用模型的缺点
        如果不摆出来其他模型的缺点，怎么能对比出 Epoll 的优点呢。
        2.1 PPC/TPC 模型
        这两种模型思想类似，就是让每一个到来的连接一边自己做事去，别再来烦我 。只是 PPC 是为它开了一个进程，而 TPC 开了一个线程。可是别烦我是有代价的，它要时间和空间啊，连接多了之后，那么多的进程 / 线程切换，这开销就上来了；因此这类模型能接受的最大连接数都不会高，一般在几百个左右。
        2.2 select 模型
        1. 最大并发数限制，因为一个进程所打开的 FD （文件描述符）是有限制的，由 FD_SETSIZE 设置，默认值是 1024/2048 ，因此 Select 模型的最大并发数就被相应限制了。自己改改这个 FD_SETSIZE ？想法虽好，可是先看看下面吧 …
        2. 效率问题， select 每次调用都会线性扫描全部的 FD 集合，这样效率就会呈现线性下降，把 FD_SETSIZE 改大的后果就是，大家都慢慢来，什么？都超时了？？！！
        3. 内核 / 用户空间 内存拷贝问题，如何让内核把 FD 消息通知给用户空间呢？在这个问题上 select 采取了内存拷贝方法。
        2.3 poll 模型
        基本上效率和 select 是相同的， select 缺点的 2 和 3 它都没有改掉。
        3. Epoll 的提升
        把其他模型逐个批判了一下，再来看看 Epoll 的改进之处吧，其实把 select 的缺点反过来那就是 Epoll 的优点了。
        3.1. Epoll 没有最大并发连接的限制，上限是最大可以打开文件的数目，这个数字一般远大于 2048, 一般来说这个数目和系统内存关系很大 ，具体数目可以 cat /proc/sys/fs/file-max 察看。
        3.2. 效率提升， Epoll 最大的优点就在于它只管你“活跃”的连接 ，而跟连接总数无关，因此在实际的网络环境中， Epoll 的效率就会远远高于 select 和 poll 。
        3.3. 内存拷贝， Epoll 在这点上使用了“共享内存 ”，这个内存拷贝也省略了。
         
        4. Epoll 为什么高效
        Epoll 的高效和其数据结构的设计是密不可分的，这个下面就会提到。
        首先回忆一下 select 模型，当有 I/O 事件到来时， select 通知应用程序有事件到了快去处理，而应用程序必须轮询所有的 FD 集合，测试每个 FD 是否有事件发生，并处理事件；代码像下面这样：


        int res = select(maxfd+1, &readfds, NULL, NULL, 120);
        if (res > 0)
        {
            for (int i = 0; i < MAX_CONNECTION; i++)
            {
                if (FD_ISSET(allConnection[i], &readfds))
                {
                    handleEvent(allConnection[i]);
                }
            }
        }
        // if(res == 0) handle timeout, res < 0 handle error
         
        Epoll 不仅会告诉应用程序有I/0 事件到来，还会告诉应用程序相关的信息，这些信息是应用程序填充的，因此根据这些信息应用程序就能直接定位到事件，而不必遍历整个FD 集合。
        int res = epoll_wait(epfd, events, 20, 120);
        for (int i = 0; i < res;i++)
        {
            handleEvent(events[n]);
        }
        5. Epoll 关键数据结构
        前面提到 Epoll 速度快和其数据结构密不可分，其关键数据结构就是：
        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;
        
        可见 epoll_data 是一个 union 结构体 , 借助于它应用程序可以保存很多类型的信息 :fd 、指针等等。有了它，应用程序就可以直接定位目标了。
        6. 使用 Epoll
        既然 Epoll 相比 select 这么好，那么用起来如何呢？会不会很繁琐啊 … 先看看下面的三个函数吧，就知道 Epoll 的易用了。
         
        int epoll_create(int size);
        生成一个 Epoll 专用的文件描述符，其实是申请一个内核空间，用来存放你想关注的 socket fd 上是否发生以及发生了什么事件。 size 就是你在这个 Epoll fd 上能关注的最大 socket fd 数，大小自定，只要内存足够。
        
        int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event );
        控制某个 Epoll 文件描述符上的事件：注册、修改、删除。其中参数 epfd 是 epoll_create() 创建 Epoll 专用的文件描述符。相对于 select 模型中的 FD_SET 和 FD_CLR 宏。
        op:EPOLL_CTL_ADD
                 Register the target file descriptor fd on the epoll instance 
              EPOLL_CTL_MOD
                  Change the event event associated with the target file descriptor fd.
              EPOLL_CTL_DEL
                   Remove  (deregister)  the  target  file descriptor fd from the epoll instance


        
        int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout);
        等待 I/O 事件的发生；参数说明：
        epfd: 由 epoll_create() 生成的 Epoll 专用的文件描述符；
        epoll_event: 用于回传代处理事件的数组；
        maxevents: 每次能处理的事件数；
        timeout: 等待 I/O 事件发生的超时值,单位 ms
        返回发生事件数。
        相对于 select 模型中的 select 函数。
        
[cpp] view plain copy print ?
  1. /* 实现功能：通过epoll, 处理多个socket 
  2.  * 监听一个端口,监听到有链接时,添加到epoll_event 
  3.  */  
  4. #include "select.h"   
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11. #include    
  12. #include    
  13.   
  14. typedef struct _CLIENT{  
  15.     int fd;  
  16.     struct sockaddr_in addr; /* client's address information */  
  17. } CLIENT;  
  18.   
  19. #define MYPORT 59000   
  20.   
  21. //最多处理的connect   
  22. #define MAX_EVENTS 500   
  23.   
  24. //当前的连接数   
  25. int currentClient = 0;   
  26.   
  27. //数据接受 buf   
  28. #define REVLEN 10   
  29. char recvBuf[REVLEN];  
  30.   
  31. //EPOLL相关    
  32. //epoll描述符   
  33. int epollfd;  
  34. //事件数组   
  35. struct epoll_event eventList[MAX_EVENTS];  
  36.   
  37. void AcceptConn(int srvfd);  
  38. void RecvData(int fd);  
  39.   
  40. int main()  
  41. {  
  42.     int i, ret, sinSize;  
  43.     int recvLen = 0;  
  44.     fd_set readfds, writefds;  
  45.     int sockListen, sockSvr, sockMax;  
  46.     int timeout;  
  47.     struct sockaddr_in server_addr;  
  48.     struct sockaddr_in client_addr;  
  49.       
  50.     //socket   
  51.     if((sockListen=socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  52.     {  
  53.         printf("socket error\n");  
  54.         return -1;  
  55.     }  
  56.       
  57.     bzero(&server_addr, sizeof(server_addr));  
  58.     server_addr.sin_family  =  AF_INET;  
  59.     server_addr.sin_port = htons(MYPORT);  
  60.     server_addr.sin_addr.s_addr  =  htonl(INADDR_ANY);   
  61.       
  62.     //bind   
  63.     if(bind(sockListen, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)  
  64.     {  
  65.         printf("bind error\n");  
  66.         return -1;  
  67.     }  
  68.       
  69.     //listen   
  70.     if(listen(sockListen, 5) < 0)  
  71.     {  
  72.         printf("listen error\n");  
  73.         return -1;  
  74.     }  
  75.       
  76.     //1. epoll 初始化   
  77.     epollfd = epoll_create(MAX_EVENTS);  
  78.     struct epoll_event event;  
  79.     event.events = EPOLLIN|EPOLLET;  
  80.     event.data.fd = sockListen;  
  81.       
  82.     //2. epoll_ctrl   
  83.     if(epoll_ctl(epollfd, EPOLL_CTL_ADD, sockListen, &event) < 0)  
  84.     {  
  85.         printf("epoll add fail : fd = %d\n", sockListen);  
  86.         return -1;  
  87.     }  
  88.       
  89.     //epoll   
  90.     while(1)  
  91.     {  
  92.         timeout=3000;                  
  93.         //3. epoll_wait   
  94.         int ret = epoll_wait(epollfd, eventList, MAX_EVENTS, timeout);  
  95.           
  96.         if(ret < 0)  
  97.         {  
  98.             printf("epoll error\n");  
  99.             break;  
  100.         }  
  101.         else if(ret == 0)  
  102.         {  
  103.             printf("timeout ...\n");  
  104.             continue;  
  105.         }  
  106.           
  107.         //直接获取了事件数量,给出了活动的流,这里是和poll区别的关键   
  108.         int n = 0;  
  109.         for(n=0; n
  110.         {  
  111.             //错误退出   
  112.             if ((eventList[n].events & EPOLLERR) ||  
  113.                 (eventList[n].events & EPOLLHUP) ||  
  114.                 !(eventList[n].events & EPOLLIN))  
  115.             {  
  116.               printf ( "epoll error\n");  
  117.               close (eventList[n].data.fd);  
  118.               return -1;  
  119.             }  
  120.               
  121.             if (eventList[n].data.fd == sockListen)  
  122.             {  
  123.                 AcceptConn(sockListen);  
  124.           
  125.             }else{  
  126.                 RecvData(eventList[n].data.fd);  
  127.                 //不删除   
  128.              //   epoll_ctl(epollfd, EPOLL_CTL_DEL, pEvent->data.fd, pEvent);   
  129.             }  
  130.         }  
  131.     }  
  132.       
  133.     close(epollfd);  
  134.     close(sockListen);  
  135.       
  136.     printf("test\n");  
  137.     return 0;  
  138. }  
  139.   
  140. /************************************************** 
  141. 函数名：AcceptConn 
  142. 功能：接受客户端的链接 
  143. 参数：srvfd：监听SOCKET 
  144. ***************************************************/  
  145. void AcceptConn(int srvfd)  
  146. {  
  147.     struct sockaddr_in sin;  
  148.     socklen_t len = sizeof(struct sockaddr_in);  
  149.     bzero(&sin, len);  
  150.   
  151.     int confd = accept(srvfd, (struct sockaddr*)&sin, &len);  
  152.   
  153.     if (confd < 0)  
  154.     {  
  155.        printf("bad accept\n");  
  156.        return;  
  157.     }else  
  158.     {  
  159.         printf("Accept Connection: %d", confd);  
  160.     }  
  161.   
  162.     //setnonblocking(confd);   
  163.   
  164.     //4. epoll_wait   
  165.     //将新建立的连接添加到EPOLL的监听中   
  166.     struct epoll_event event;  
  167.     event.data.fd = confd;  
  168.     event.events =  EPOLLIN|EPOLLET;  
  169.     epoll_ctl(epollfd, EPOLL_CTL_ADD, confd, &event);  
  170. }  
  171.   
  172. //读取数据   
  173. void RecvData(int fd)  
  174. {  
  175.     int ret;  
  176.     int recvLen = 0;  
  177.       
  178.     memset(recvBuf, 0, REVLEN);  
  179.     printf("RecvData function\n");  
  180.       
  181.     if(recvLen != REVLEN)  
  182.     {  
  183.         while(1)  
  184.         {  
  185.             //recv数据   
  186.             ret = recv(fd, (char *)recvBuf+recvLen, REVLEN-recvLen, 0);  
  187.             if(ret == 0)  
  188.             {  
  189.                 recvLen = 0;  
  190.                 break;  
  191.             }  
  192.             else if(ret < 0)  
  193.             {  
  194.                 recvLen = 0;  
  195.                 break;  
  196.             }  
  197.             //数据接受正常   
  198.             recvLen = recvLen+ret;  
  199.             if(recvLen
  200.             {  
  201.                 continue;  
  202.             }  
  203.             else  
  204.             {  
  205.                 //数据接受完毕   
  206.                 printf("buf = %s\n",  recvBuf);  
  207.                 recvLen = 0;  
  208.                 break;  
  209.             }  
  210.         }  
  211.     }  
  212.   
  213.     printf("content is %s", recvBuf);  
  214. } 

你可能感兴趣的:(嵌入式开发,Linux)

  • PHP 处理csv 文件 解决中文乱码 MountainYanYL PHPcsvphp
    /***读取csv格式的数据*@param$file*@returnarray*/publicstaticfunctionread_csv($file){setlocale(LC_ALL,'zh_CN');//linux系统下生效$data=[];//返回的文件数据行if(!is_file($file)&&!file_exists($file)){return$data;}$cvs_file=fo
  • PHP编译安装oci8扩展 爬山虎还上班 phpoci8
    文档：https://www.php.net/manual/zh/ref.pdo-oci.php如果Oracle数据库与PHP在同一台机器上，则数据库软件已经包含了必要的库。当PHP在另一台机器上时，请使用免费的»OracleInstantClient库点击“OracleInstantClient”进入官网相关地址，根据服务器情况选择对应版本，此处我选择的OracleLinux7（OracleIn
  • Miniconda 安装及使用 achi010 PythonMiniconda安装及使用MinicondaMiniconda安装Miniconda常用命令LinuxMinicondaPython环境管理UbuntuMiniconda
    文章目录前言1、Miniconda简介2、Linux环境说明2.1、安装2.2、配置2.3、常用命令2.4、常见问题及解决方案前言在Python中，“环境管理”是一个非常重要的概念，它主要是指对Python解释器及其相关依赖库进行管理和隔离，以确保开发环境的稳定性和项目的可移植性。什么是Python环境Python解释器：Python是一种解释型语言，代码的运行需要通过Python解释器来执行。不
  • 重生之我在CSDN学基础语法 AI26108 算法c语言c++开发语言python数据结构java
    C语言是一种通用的、结构化的、静态类型的编程语言，被广泛用于系统编程、嵌入式开发、应用软件开发等领域。以下是C语言的基础语法详细讲解。1.变量与数据类型1.1变量声明变量是存储数据的容器，在使用之前必须先声明：inta;//声明一个整型变量floatb;//声明一个浮点型变量charc;//声明一个字符型变量1.2数据类型C语言的基本数据类型如下：数据类型关键字说明整型int存储整数字符型char
  • Elasticstack-日志分析平台 尼古拉斯-邓 linuxkafkacentos
    #ElasticStack-日志分析平台##1.Filebeat```shellvim/etc/hostsip1dijiaip2meimeiip3biaobei```###Filebeat安装```shellcurl-L-Ohttps://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.13.2-linux-x86_64.tar.g
  • xodooIP地址定位 odoo实施 XODOOPROXodooodoopython
    //src/packages/python/geoip2.rs实现特点：跨平台支持：通过Rust原生实现，兼容Windows、Linux、macOS等主流操作系统类型安全：使用Rust的Option类型处理可能缺失的字段严格校验IP地址格式自动处理编码转换性能优化：数据库文件只加载一次内存映射方式读取数据零拷贝解析技术错误处理：明确的错误类型（IOError/ValueError）友好的错误提示信
  • C/C++框架和库推荐 大王算法 C++入门及项目实战宝典C/C++开发实战365C++
    值得学习的C语言开源项目-1.WebbenchWebbench是一个在Linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力下工作的性能，最多可以模拟3万个并发连接去测试网站的负载能力。Webbench使用C语言编写,代码实在太简洁，源码加起来不到600行。下载链接：http://home.tiscali.cz/~cz210552/web
  • 将本地文件上传到远程Linux服务器SCP的用法
    服务器文件传输工具指南：SCP与rsync一、SCP的介绍SCP命令（SecureCopy）是一个用于在服务器和本地计算机之间传输文件的命令行工具。1.核心特性基于SSH协议的安全传输支持文件/目录传输保留基础文件属性2.基础语法scp[选项]源路径目标路径3.常用操作3.1通过scp实现文件上传3.1.1单文件上传#上传文件scp./local_diruser@host:/remote_dest
  • Linux--gnome MzKyle Linuxlinuxchrome运维
    一、Gnome核心命令概述Gnome是一款流行的Linux桌面环境，拥有一系列强大的命令来实现系统设置、终端操作、显示管理等多种功能。以下是对Gnome相关命令的分类概述：命令分类常用命令示例核心功能系统设置gsettings、gnome-control-center全局配置管理终端操作gnome-terminal启动终端显示管理gdm、gdmflexiserver图形显示管理器脚本执行gjs、g
  • ARM嵌入式实时系统(RTOS) 中通过页表关闭DCACHE的方法 papaofdoudou 嵌入式系统内存管理armlinux
    现在的嵌入式实时系统规模越来越大，很多在linux中使用的特性，例如虚拟内存管理，动态加载等功能也加入进来，进一步增加了RTOS开发的难度．在应用开发中，和cache相关的同步问题有两个，一个是flush操作，另一个是invalidate操作，有时候为了确认问题是否和cache同步有关，需要关闭dcache来验证．这里介绍一种经过验证过的通过页表项关闭DCACHE的实践。Cortex-A7中启用c
  • Linux书签上下移动 海天鹰 Qtqt
    步骤读书签文件，分割到QStringList，点击右键菜单获取序号，交换序号，写书签文件。QStringList.swap(int,int)过时，QStringList.swapItemsAt(int,int)代替。书签文件路径mainwindow.hconstQStringfilepath_bookmark=QStandardPaths::writableLocation(QStandardPa
  • linux下命令行方式的音量控制 热爱生活热爱你 服务器c++linux
    输入命令：alsamixer；//设置系统音量，这个百分比会有一定的误差存在amixersetSpeaker100%//设置系统麦克风amixersetMic100%c++代码可以执行运行上面的命令：QStringyl="amixersetSpeaker100%";QByteArraycmd;cmd.append(yl);//也可以ba2=s2.toLatin1();constchar*c_cmd
  • Linux 找回 Root 密码（多发行版本） 可问 可问春风 Linux从新手到入门linuxchrome运维
    适用于大多数Linux发行版（Ubuntu、CentOS、Debian等），无需第三方工具，需物理接触服务器或系统启动权限。步骤1：重启系统并进入GRUB引导菜单重启系统，看到启动画面时，快速按下Esc、Shift或E（不同系统按键不同，可多试几次）。进入GRUB菜单后，选择要修改的系统内核选项（通常第一个），按e进入编辑模式。步骤2：修改内核启动参数找到以linux或linux16或linuxe
  • Umi-OCR 使用与安装教程 平依佩Ula
    Umi-OCR使用与安装教程项目地址:https://gitcode.com/gh_mirrors/um/Umi-OCR1.项目目录结构及介绍Umi-OCR的项目结构精心组织，以支持其多方面功能。以下是主要组成部分的概览：Umi-OCR├──Umi-OCR.exe#主执行文件，Windows平台上直接运行的程序├──umi-ocr.sh#Linux上的启动脚本└──UmiOCR-data├──ma
  • linux jvm gc日志分析,JVM GC 日志详解 一只小小的IOS linuxjvmgc日志分析
    本文采用的JDK版本：javaversion"1.8.0_144"Java(TM)SERuntimeEnvironment(build1.8.0_144-b01)JavaHotSpot(TM)64-BitServerVM(build25.144-b01,mixedmode)一、GC日志参数设置JVMGC格式日志的主要参数包括如下8个：-XX:+PrintGC输出简要GC日志-XX:+PrintGC
  • 【Linux】日志插件 s_little_monster_ Linuxlinux数据库oracle运维学习经验分享笔记
    个人主页~日志插件一、日志文件的重要性二、日志文件的简单实现1、comm.hpp2、log.hpp三、测试用例一、日志文件的重要性故障排查与问题定位快速发现问题：日志能够实时记录系统运行过程中的各种事件和状态信息，当系统出现故障或异常时，通过查看日志可以快速察觉到问题的发生，例如，服务器突然崩溃，日志中可能会记录下崩溃前的错误信息、异常堆栈，帮助运维人员第一时间得知系统出现了故障精准定位根源：详细
  • 【Android】adb shell基本使用教程 Vesper63 androidadb
    adbshell是AndroidDebugBridge(ADB)工具中的一个命令，用于在连接的Android设备或模拟器上执行shell命令。通过adbshell，你可以直接与设备的Linux内核交互，执行各种操作。基本用法启动adbshell：在终端或命令提示符中输入以下命令：adbshell这将进入设备的shell环境，提示符通常会变为$或#（#表示root权限）。执行单个命令：如果你只想执行
  • SSL证书自动续签(解决泛域名续签问题) 月会 ssl自动续签
    文章目录SSL证书自动生成并自动续期Let’sEncryptCertbot介绍申请ssl证书下载certbot申请证书非泛域名申请证书nginx使用证书证书续期脚本linux定时执行脚本泛域名SSL证书自动生成并自动续期自动续期使用Let’sEncrypt证书颁发机构和certbot客户端共同完成Let’sEncryptLet’sEncrypt是一家免费、开放、自动化的证书颁发机构（CA），为公众
  • 基于Mosquitto和Paho，在C++中使用MQTT 牛魔王的小怪兽 MQTTc++开发语言网络协议
    基于Mosquitto和Paho，使用C++进行MQTT相关应用的开发文章目录基于Mosquitto和Paho，使用C++进行MQTT相关应用的开发1.什么是MQTT2.MQTT的应用场景3.基于Paho，在C++中使用MQTT3.1.下载Paho库3.2.发布消息的代码示例3.3.订阅消息的代码示例3.4.综合示例3.4.1.LinuxC++发布端代码3.4.2.LinuxC++订阅端代码4.基
  • ubuntu12 mysql5.6_Ubuntu 12 安装 MySQL 5.6.26 及 问题汇总 乔德地 ubuntu12mysql5.6
    安装过程：#安装依赖库sudoapt-getinstalllibaio-dev#移动到安装目录sudomkdir/opt/software/mysqlcd/opt/software-backup/lnmp/source2/mysqltar-xzvf./mysql-5.6.26-linux-glibc2.5-x86_64.tar.gzsudomv./mysql-5.6.26-linux-glibc2
  • 基于oracle linux的 DBI/DBD 标准化安装文档(二) 文档
    一、安装DBIDBI(DatabaseInterface)是perl连接数据库的接口。其是perl连接数据库的最优方法，他支持包括Orcale,Sybase,mysql,db2等绝大多数的数据库，下面将简要介绍其安装方法。1.1解压tar-zxvfDBI-1.616_901.tar.gz1.2安装依赖yuminstallperl-ExtUtils-CBuilderperl-ExtUtils-Mak
  • linux（ubuntu）中Conda、CUDA安装Xinference报错ERROR: Failed to build (llama-cpp-python) 小胡说技书 杂谈/设计模式/报错Data/Python/大模型linuxubuntuconda大模型pythonXinference
    文章目录一、常规办法二、继续三、继续四、缺少libgomp库（最终解决）在Conda环境中安装libgomp如果符合标题情况执行的：pipinstall"xinference[all]"大概率是最终解决的情况。一、常规办法llama-cpp-python依赖CMake、Make和g++来编译，所以可能是缺少依赖或者环境配置不对。按照以下步骤排查问题并解决：1.确保Python版本符合要求llama
  • LINUX下的tcp协议 Ccc030. linuxtcp/ip运维
    TCP1.面向数据流（流式套接字）2.建立连接3.安全可靠的传输协议应用场景：HTTP,MQTT,FTP三次握手：TCP建立连接时，需要进行三次握手，确保收发数据前，双方都已准备就绪。四次挥手：TCP断开连接时，需要进行四次挥手，从而确保通信双发都已收发数据结束。C/S模型：ssize_trecv(intsockfd,void*buf,size_tlen,intflags);功能：从tcp套接字接
  • Linux线程 Ccc030. linuxjavajvm
    线程的概念。1.线程轻量级的进程2.线程的创建线程由某个进程创建，从属于某个进程内存：由所在进程为其分配独立的栈区空间（默认8M）与其他线程和所在的进程共用堆区，数据区，文本去。内核存储线程控制块。线程是cpu任务调度的最小单位进程是操作系统资源分配的最小单位进程和线程的区别：1.线程是cpu任务调度的最小单位进程是操作系统资源分配的最小单位2.线程是一个轻量级的进程，所在进程为其分配独立的栈区空
  • 如何编写vscode的配置文件c_cpp_properties.json 小秋slam实战 从零开始学SLAMvscode
    文章目录配置`c_cpp_properties.json`文件改变VScode中空格长度VSCode中C/C++无法跳转到定义c_cpp_properties.json安装插件配置c_cpp_properties.json文件假设你已经安装了GCC和G++编译器，{"configurations":[{"name":"Linux","includePath":
  • Linux基础指令详解：掌握Linux系统的必备技能 A-Kamen linux服务器运维
    Linux基础指令详解：掌握Linux系统的必备技能在数字化时代，Linux以其稳定性、安全性和灵活性成为了服务器、嵌入式系统以及开发环境中的首选操作系统。对于初学者而言，掌握Linux的基本指令是踏入这个强大操作系统的第一步。本文将详细介绍一些Linux系统中最为基础且常用的指令，帮助读者快速上手Linux。一、Linux基础指令概述Linux指令行界面（CLI）是其核心部分之一，通过命令行可以
  • Linux arp(地址解析协议) 命令使用详解 linux
    简介arp（地址解析协议）命令用于查看、添加和修改系统的ARP缓存。ARP缓存存储了IP地址和MAC地址之间的映射，有助于网络中的计算机高效通信。许多现代Linux发行版使用ipneigh（来自iproute2）而不是arp。但是，arp对于管理ARP表仍然有用。示例用法显示ARP表arp-a或ipneighshow#这将显示当前ARP缓存，显示IP地址、MAC地址和网络接口示例输出192.168
  • 基于oracle linux的 DBI/DBD 标准化安装文档（三） oracle
    一、安装DBIDBI(DatabaseInterface)是perl连接数据库的接口。其是perl连接数据库的最优方法，他支持包括Orcale,Sybase,mysql,db2等绝大多数的数据库，下面将简要介绍其安装方法。1.1解压tar-zxvfDBI-1.616_901.tar.gz1.2安装依赖yuminstallperl-ExtUtils-CBuilderperl-ExtUtils-Mak
  • linux常用基础命令_最新 脚大江山稳 linux运维服务器
    常用命令查看当前目录下个各个文件大小查看当前系统储存使用情况查看当前路径删除当前目录下所有包含".log"的文件linux开机启动jar更改自动配置文件后操作关闭自启动linux静默启动java服务查询端口被占用查看软件版本重启关机开机启动取别名清空当前行创建文件touch创建文件夹查找文件/文件名/大小查找查看文件内容cat/more删除文件或文件夹管道符|过滤grep命令echo命令输出内容重
  • 【Linux】基本指令(一) 安 度 因 Linuxlinux服务器c语言centos运维
    作者主页：@安度因学习社区：安度因的学习社区专栏链接：Linux文章目录操作系统简述学习指令的原因ls指令pwd指令cd指令touch指令tree命令mkdir指令rmdir和rm指令nano指令clear指令whoami指令常用键位今天，我们开始Linux的学习。本篇博客内容为操作系统简述、Linux基本指令、和几个Linux常用键位。操作系统简述操作系统概念：一款进行软硬件资源管理的软件。为什
  • Java实现的简单双向Map，支持重复Value superlxw1234 java双向map
    关键字：Java双向Map、DualHashBidiMap     有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。   数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。   即：既要根据Key找Value，又要根据Value
  • PL/SQL触发器基础及例子 百合不是茶 oracle数据库触发器PL/SQL编程
      触发器的简介; 触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用,   一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行, 触发时间：指明触发器何时执行，该值可取： before：表示在数据库动作之前触发
  • [时空与探索]穿越时空的一些问题 comsci 问题
          我们还没有进行过任何数学形式上的证明,仅仅是一个猜想.....       这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
  • easy ui datagrid上移下移一行 商人shang js上移下移easyuidatagrid
    /** * 向上移动一行 * * @param dg * @param row */ function moveupRow(dg, row) { var datagrid = $(dg); var index = datagrid.datagrid("getRowIndex", row); if (isFirstRow(dg, row)) {
  • Java反射 oloz 反射
    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 首先看看java中的Class package demo; public class ClassTest { /*先了解java中的Class*/ public static void main(String[] args) { //任何一个类都
  • springMVC 使用JSR-303 Validation验证 杨白白 springmvc
    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 登录需要验证类 public class Login { @NotEmpty
  • log4j 香水浓 log4j
    log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE #log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML #console log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender log4
  • 使用ajax和history.pushState无刷新改变页面URL agevs jquery框架Ajaxhtml5chrome
    表现 如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 是什么有这么强大的功能呢？ HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
  • centos中文乱码 AILIKES centosOSssh
    一、CentOS系统访问 g.cn ，发现中文乱码。 于是用以前的方式：yum -y install fonts-chinese CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。       后来，终于找到以下方法可以解决，需要两个中文支持的包： fonts-chinese-3.02-12.
  • 触发器 baalwolf 触发器
    触发器(trigger)：监视某种情况，并触发某种操作。 触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 语法： create trigger triggerName after/before 
  • JS正则表达式的i m g bijian1013 JavaScript正则表达式
            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
  • HTML5模式和Hashbang模式 bijian1013 JavaScriptAngularJSHashbang模式HTML5模式
            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 html5Mode         一个布尔值，标识$location服务是否运行在HTML5模式下。 ha
  • [Maven学习笔记六]Maven生命周期 bit1129 maven
    从mvn test的输出开始说起   当我们在user-core中执行mvn test时，执行的输出如下：   /software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错 bit1129 hadoop
    运行于Yarn的Map Reduce作业，可能发生失败的点包括 Task Failure Application Master Failure Node Manager Failure Resource Manager Failure 1. Task Failure 任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
  • 记一次数据推送的异常解决端口解决 ronin47 记一次数据推送的异常解决
    　　 需求：从db获取数据然后推送到B         程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 　　　service iptables stop
  • 巧用视错觉-UI更有趣 brotherlamp UIui视频ui教程ui自学ui资料
    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
  • 线段树-poj1177-N个矩形求边长（离散化+扫描线） bylijinnan 数据结构算法线段树
    package com.ljn.base; import java.util.Arrays; import java.util.Comparator; import java.util.Set; import java.util.TreeSet; /** * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177
  • HTTP协议详解 chicony http协议
    引言                                 
  • Scala设计模式 chenchao051 设计模式scala
    Scala设计模式                我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
  • 安装mysql daizj mysql安装
    安装mysql   (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除)      执行命令rpm -qa |grep mysql 检查是否删除干净   (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
  • HTTP状态码大全 dcj3sjt126com http状态码
    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
  • asihttprequest上传图片 dcj3sjt126com ASIHTTPRequest
    NSURL *url =@"yourURL"; ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url]; [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
  • C语言中，关键字static的作用 e200702084 C++cC#
    在C语言中，关键字static有三个明显的作用： 1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
  • win7/8使用curl geeksun win7
    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。 下载地址：  http://curl.haxx.se/download.html 请选择不带SSL的版本，否则还需要安装SSL的支持包   2.  可以给Windows增加c
  • Creating a Shared Repository; Users Sharing The Repository hongtoushizi git
    转载自：   http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/ Commands discussed in this section: git init –bare git clone git remote git pull git p
  • Java实现字符串反转的8种或9种方法 Josh_Persistence 异或反转递归反转二分交换反转java字符串反转栈反转
    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： http://josh-persistence.iteye.com/blog/2205768   /** * */ package com.wsheng.aggregator.algorithm.string; import java.util.Stack; /**
  • 代码实现任意容量倒水问题 home198979 PHP算法倒水
    形象化设计模式实战             HELLO!架构                     redis命令源码解析   倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
  • Druid datasource zhb8015 druid
    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
  • 两种启动监听器ApplicationListener和ServletContextListener spjich javaspring框架
    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器   ServletContextListener  特点: 依赖于sevlet容器，需要配置web.xml 使用方法: public class StartListener implements
  • JavaScript Rounding Methods of the Math object 何不笑 JavaScriptMath
        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他