精华内容
下载资源
问答
  • 内核文件句柄数量

    2020-08-10 19:43:21
    file-max定义了Linux内核可分配的最大数量的文件句柄,当检测文件句柄耗尽时,需要增加file-max值。 / # cat /proc/sys/fs/file-max 1597700 内核函数files_maxfiles_init计算系统默认的最大文件数量,依据是每个...

    涉及三个文件file-max,file-nr和nr-open。

    file-max

    file-max定义了Linux内核可分配的最大数量的文件句柄,当检测到文件句柄耗尽时,需要增加file-max值。

    / # cat /proc/sys/fs/file-max
    1597700
    

    内核函数files_maxfiles_init计算系统默认的最大文件数量,依据是每个文件及与其关联的inode和dcache结构,总的大小约为1K。默认文件占用的空间不超出内存的10%,file-max的最小值为NR_FILE,即8192个。

    void __init files_maxfiles_init(void)
    {
        unsigned long n;
        unsigned long memreserve = (totalram_pages - nr_free_pages()) * 3/2;
    
        memreserve = min(memreserve, totalram_pages - 1);
        n = ((totalram_pages - memreserve) * (PAGE_SIZE / 1024)) / 10;
    
        files_stat.max_files = max_t(unsigned long, n, NR_FILE);
    }
    
    #define NR_FILE  8192   /* this can well be larger on a larger system */
    

    在内核的文件分配函数中,调用alloc_empty_file判断当前打开的文件数量是否已经超出限定的最大文件数量(files_stat.max_files),将会显示信息:“VFS: file-max limit %lu reached”。

    struct file *alloc_empty_file(int flags, const struct cred *cred)
    {
        static long old_max;
        struct file *f;
    
        /* Privileged users can go above max_files
         */
        if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
            /* percpu_counters are inaccurate.  Do an expensive check before we go and fail. */
            if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
                goto over;
        }
        f = __alloc_file(flags, cred);
        if (!IS_ERR(f)) percpu_counter_inc(&nr_files);
    
        return f;
    
    over:
        /* Ran out of filps - report that */
        if (get_nr_files() > old_max) {
            pr_info("VFS: file-max limit %lu reached\n", get_max_files());
            old_max = get_nr_files();
        }
        return ERR_PTR(-ENFILE);
    

    如下函数get_max_files用于获取内核设置的最大文件数量。

    /* Return the maximum number of open files in the system
     */
    unsigned long get_max_files(void)
    {
        return files_stat.max_files;
    }
    

    file-nr

    历史上,内核可以动态的分配文件句柄,但是不能进行释放。file-nr文件中的三个值分别表示:分配的文件句柄数量,已分配但是未使用的句柄数量,以及最大的文件句柄数量。在内核版本2.6之后,第二个值总是为零,意味着分配的文件句柄数量与使用的句柄数量完全相同。

    / # cat /proc/sys/fs/file-nr
    20160   0       1597700
    

    nr_open

    nr_open表示单个进程可分配的文件句柄数量,默认值为:1024*1024 (1048576)。实际的数量还受到RLIMIT_NOFILE定义的资源项限制。

    / # cat /proc/sys/fs/nr_open
    1048576
    

    如下,将文件数量限制在1024。

    $ ulimit -a
    open files                      (-n) 1024
    

    在内核文件fs/file.c中,将nr_open默认为:1024*1024。

    unsigned int sysctl_nr_open __read_mostly = 1024*1024;
    

    内核版本 5.0

    展开全文
  • 基于linux ,使用select检测串口句柄事件,同时进行超时判断的串口485读写操作。为高效可控的linux串口操作例程。tcsetattr,tcflush,select,ioctl,gettimeofday。485收发方向切换。
  • select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。程序会停在select这里等待,直到被监视的文件句柄有一个或多个发生了状态改变。 select函数原型? 这里有几个参数。 1.参数nfds是需要监视的...

    1. select是做什么的?

    系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序监视**多个文件句柄**的状态变化的。程序会停在select这里等待,直到被监视的文件句柄有一个或多个发生了状态改变。
    

    2. select函数原型?

     ![这里写图片描述](https://img-blog.csdn.net/20170606093025905?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2F5aGVsbG9fd29ybGQ=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
     这里有几个参数。
     1.参数nfds是需要监视的最大的文件描述符值+1。
    
    2.参数rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合,可写文件描述符的集合及异常文件描述符的集合。 
    如果对某一个的条件不感兴趣,就可以把它设为空指针。struct fd_set可以理解为一个集合,这个集合中存放的是文件描述符,可通过以下四个宏进行设置:
    
        void FD_ZERO(fd_set *fdset);           //清空集合
        void FD_SET(int fd, fd_set *fdset);   //将一个给定的文件描述符加入集合之中
        void FD_CLR(int fd, fd_set *fdset);   //将一个给定的文件描述符从集合中删除
        int FD_ISSET(int fd, fd_set *fdset);   // 检查集合中指定的文件描述符是否可以读写 

    3.timeout告知内核等待所指定描述字中的任何一个就绪可花多少时间。其timeval结构用于指定这段时间的秒数和微秒数。

    struct timeval{
              long tv_sec;   //seconds
              long tv_usec;  //microseconds
           };

    这个参数有三种选项:
    (1)永远等待下去:仅在有一个描述字准备好I/O时才返回。为此,把该参数设置为空指针NULL。
    (2)等待一段固定时间:在有一个描述字准备好I/O时返回,但是不超过由该参数所指向的timeval结构中指定的秒数和微秒数。
    (3)根本不等待:检查描述字后立即返回,这称为轮询。为此,该参数必须指向一个timeval结构,而且其中的定时器值必须为0。

    select特点:

    1、可监控的文件描述符个数取决与sizeof(fd_set)的值。本人服务器上sizeof(fd_set)=512,每bit表示一个文件描述符,服务器上支持的最大文件描述符是4096(512*8)。据说可调,另有说虽然可调,但调整上限受于编译内核时的变量值。

    2、将fd加入select监控集的同时,还要使用一个数据结构array保存放到select监控集中的fd。
    一是用于在select返回后,array作为源数据和fd_set进行FD_ISSET判断。
    二是select返回后会把以前加入的但并无事件发生的fd清空,则每次开始select前都要重新从array取得fd逐一加入(FD_ZERO最先),扫描array的同时取得fd最大值maxfd,用于select的第一个参数。

    3、select模型必须在select前循环array(加fd,取maxfd),select返回后循环array(FD_ISSET判断是否有时间发生)。

    select缺点:

    (1)每次调用select,都需要把fd集合从用户态拷贝到内核态,这个开销在fd很多时会很大。
    (2)同时每次调用select都需要在内核遍历传递进来的所有fd,这个开销在fd很多时也很大。
    (3)select支持的文件描述符数量太小了,默认是1024。

    测试程序:

    server端:

    #include<stdio.h>
    #include<stdlib.h>
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<arpa/inet.h>
    #include<netinet/in.h>
    #include<string.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    
    int array_fds[1024];
    
    int startup(char *ip,int port)
    {
        int sock = socket(AF_INET,SOCK_STREAM,0);
        if(sock < 0)
        {
            perror("socket");
            exit(1);
        }
        int flg = 1;
        setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&flg,sizeof(flg));
    
        struct sockaddr_in local;
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = inet_addr(ip);
    
        if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){
            perror("bind");
            exit(3);
        }
    
        if(listen(sock,10)<0){
            perror("listen");
            exit(4);
        }
        return sock;
    }
    
    int main(int argc ,char* argv[])
    {
        if(argc != 3)
        {
            printf("usage: %s [ip] [port]\n",argv[0]);
            return 1;
        }
    
        int maxfd = 0;
        int listenSock = startup(argv[1],atoi(argv[2]));
    
        fd_set rfds;
        array_fds[0] = listenSock;
        int array_size = sizeof(array_fds)/sizeof(array_fds[0]);
        int i = 1;
        for(;i<array_size;++i)
            array_fds[i] = -1;
    
        while(1)
        {
            struct timeval timeout = {0,0};
            FD_ZERO(&rfds);
            maxfd = -1;
            for(i = 0;i<array_size;++i)
            {
                if(array_fds[i] > 0){
                    FD_SET(array_fds[i],&rfds);
                    if(array_fds[i] > maxfd)
                        maxfd = array_fds[i];
                }
            }
    
        switch(select(maxfd+1,&rfds,NULL,NULL,NULL))//这里最后一个参数为timeout 则为等待一段时间后退出,若为NULL则表示阻塞等待
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("select");
                break;
            default:
                {
                    int j = 0;
                    for(;j<array_size;++j)
                    {
                        if(array_fds[j] < 0)
                            continue;
                            //j==0表示listensock响应
                        if(j == 0 && FD_ISSET(array_fds[j],&rfds)){
                            struct sockaddr_in client;
                            socklen_t len = sizeof(client);
                            int new_fd = accept(array_fds[j],\
                                                (struct sockaddr*)&client,&len);
                            if(new_fd < 0){
                                perror("accept");
                                continue;
                            }else{
                                printf("get a new client:{%s:%d}\n",\
                                        inet_ntoa(client.sin_addr),\
                                        ntohs(client.sin_port));
                                int k = 1;
                                for(;k<array_size;++k){
                                    if(array_fds[k] < 0){
                                        array_fds[k] = new_fd;
                                        break;
                                    }
                                }
                            if(k == array_size){
                                close(new_fd);
                            }
                        }
                    }
                    //j!=0表示其他的响应
                    else if(j!=0 && FD_ISSET(array_fds[j],&rfds)){
                        char buf[10240];
                        ssize_t s = read(array_fds[j],\
                                         buf,sizeof(buf)-1);
                        if(s > 0){
                            buf[s] = 0;
                            printf("client say :%s\n",buf);
                        }else if(s == 0){
                            printf("client quit~\n");
                            close(array_fds[j]);
                            array_fds[j] = -1;
                        }else{
                            perror("read");
                            close(array_fds[j]);
                            array_fds[j] = -1;
                        }   
                    }
                }
            break;
        }
      }
     }
    }

    实验结果:
    这里写图片描述

    展开全文
  • Linux 下,IO事件对应的句柄就是文件描述符,信号事件对应的 句柄就是信号值。 2.事件多路分发器 事件的到来是随机的,异步的。我们无法预知程序何时收到一个客户连接请求,亦或者收到一个暂停...
    1.句柄
    	IO框架库要处理的对象,即 IO事件,信号和定时事件,统一称为事件源。
    	一个事件源通常和一个句柄绑在一起。句柄的作用是,当内核检测到就绪事件时,它将通过
    	句柄来通知应用程序这一事件。Linux 下,IO事件对应的句柄就是文件描述符,信号事件对应的
    	句柄就是信号值。
    
    
    2.事件多路分发器
    	事件的到来是随机的,异步的。我们无法预知程序何时收到一个客户连接请求,亦或者收到一个暂停信号。
    	所以程序需要循环的等待并处理事件,这就是事件循环。在事件循环中,等待事件一般使用IO复用技术来实现。
    	IO 框架库一般将系统支持的各种IO复用系统调用封装成统一的接口,称为事件多路分发器。事件多路分发器的 demultiplex
    	方法是等待事件的核心函数,起内部调用的是 select, poll, epoll_wait 等函数.
    
    
    3.事件处理器/具体事件处理器
    	事件处理器执行事件对应的业务逻辑。它通常包含一个或者多个 handle_event 回调函数,这些回调函数在事件循环中被执行。
    	IO框架库提供的事件处理器通常是一个接口,用户需要继承它来实现自己的事件处理器,即具体事件处理器。因此,事件处理器中的
    	回调函数一般被声明为虚函数,以支持用户的扩展。
    
    4.Reactor
    	Reactor 是 IO 框架库的核心。它提供的几个主要方法是:
    
    		handle_events.该方法执行事件循环。它重复如下过程:等待事件,然后依次处理所有就绪事件对应的事件处理器。
    
    		register_handler. 该方法调用事件多路分发器的 register_event 方法来往事件多路分发器中注册一个事件。
    
    		remove_handle. 该方法调用事件多路分发器的 remove_event 方法来删除事件多路分发器中的一个事件。

     

     

    12.1 IO 框架库概述

     

    12.2 Libevent 源码分析

     

     

     

     

     

     

     

    展开全文
  • 支持健康检测,限制内存、线程数、句柄数,超限时重启应用服务 支持应用服务定时重启,通过配置指定 支持看门狗WatchDog,通过配置指定要守护的目标应用服务,如果目标停止则启动 支持配置文件修改服务名,一个应用...
  • 采用的是集合的方式,将关心的事件放置集合队列(最多监听1024个)中,轮询访问(每次都会检测所有的句柄)拿到一个已就绪的就会返回,(内核态到用户态的切换来拿事件),内部再使用位运算,将可读,可写,异常三个...

    一、select
    采用的是集合的方式,将关心的事件放置集合队列(最多监听1024个)中,轮询访问(每次都会检测所有的句柄)拿到一个已就绪的就会返回,(内核态到用户态的切换来拿事件),内部再使用位运算,将可读,可写,异常三个事件分开来,
    1、select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024,单纯的改变进程打开的文件描述符个数,并不能改变select监听的文件个数。
    2、解决了1024以下客户端使用select 是很合适的,select采用的是轮询模式,但如果连接客户过多,会大大降低服务器的响应效率。
    3、循环次数过多,每次有一个文件描述符准备好就会返回,可能就会一直处于激活状态,因为有文件描述符的拷贝(每次都要扫描注册的文件描述符集合,将已准备好的文件描述符返回给用户),系统从内核态切换用户态的次数会过多,造成性能下降

    int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,struct timeval* timeout);
    //nfds: 监控的文件描述符的个数
    //exceptfds 监控异常发生到达文件描述符集合
    //timeout:定时阻塞监控时间
      1、null   永久等下去
      2、设置timeval  ,等待固定时间
      3、将timeval中时间设置为0,检查描述字后立即返回,轮询
    

    二、poll
    poll 比select 能 好一点,也是在指定时间内轮询一定数量的文件描述符,以测试是否有文件描述符就绪

    三、epoll
    把用户关心的文件描述符直接放置内核里的一个事件表(红黑树)中,不会像select与poll那样,每次调用都要传入文件描述符集或事件集,epoll_wait()函数当检测到就绪事件时,会将已准备好的文件描述符拷贝到它第二个参数指向的数组(链表)中,系统只需要从数组中取事件即可。用户态与内核态切换的次数并不多,极大地提高了效率

    三个系统调用
    int epoll_create(int size);  
    
    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);  
    
    int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
    
      首先要调用epoll_create建立一个epoll对象。参数size是内核保证能够正确处理的最大句柄数,多于这个最大数时内核可不保证效果。
    epoll_ctl可以操作上面建立的epoll,例如,将刚建立的socket加入到epoll中让其监控,或者把 epoll正在监控的某个socket句柄移出epoll,不再监控它等等。
    epoll_wait在调用时,在给定的timeout时间内,当在监控的所有句柄中有事件发生时,就返回用户态的进程。
    
    
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <stdlib.h>
    #include <sys/epoll.h>
    #include <unistd.h>
    #define  SIZE 64
    const char* msg = "HTTP/1.0 200 OK\r\n\r\n<html><h1>hello epoll!<h1></html>\r\n";
    
    
    static void Usage(const char* proc)
    {
        printf("Usage: \n\t %s [local_ip][local_port]\n\n",proc);
    }
    
    int startup(const char *ip,int port)
    {
    	int sock = socket(AF_INET,SOCK_STREAM,0);//创建套结字
    	if(sock<0)
    	{
    		perror("socket");
    		exit(2);
    	}
        //当服务器异常关闭时,清除套结字,就可再次重启
        int opt = 1;
        setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(int));
        //设置结构体,填充自己ip与端口号
    	struct sockaddr_in local;
    	local.sin_family = AF_INET;
    	local.sin_port = htons(port);//端口号的转换
    	local.sin_addr.s_addr = inet_addr(ip);//ip
    	
    	if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)//绑定套结字
    	{
    		perror("bind");
    		exit(3);
    	}
    	if(listen(sock,10)<0)//监听队列,里面有10个文件描述符,返回已经准备好链接的那一个
    	{
    		perror("listen");
    		exit(4);
    	}
    	return sock;
    }
    
    
    int main(int argc,char* argv[])
    {
    	    if(argc!=3)
            {
    		    Usage(argv[0]);
    		    return 1;
    	    }
    
    	    int listen_sock = startup(argv[1],atoi(argv[2]));//把得到的套结字作为监听套结字
            int epfd = epoll_create(256);//创建epoll模型
            if(epfd < 0)
            {
                perror("epoll_create   is   failed\n");
                return 5;
            }
            printf("listen_sock:%d\n",listen_sock);
            //设置结构体事件,并把事件与套结字放在就绪队列中
            struct epoll_event ev;
            ev.events = EPOLLIN;//表示对应的文件描述符可以读
            ev.data.fd = listen_sock;
            epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&ev);//事件注册函数,将监听套结字加入监听事件
            int nums = -1;
            int timeout = 10000;//可设置-1阻塞0非阻塞
    		  //struct timeval timeout = {1,0};   //设置为0,0  非阻塞状态
            struct epoll_event revs[SIZE];
    
    
    
        //####################################################################################################
            //对已连接的客户端进行数据处理
            while(1)
            {
    	     	switch((nums = epoll_wait(epfd,revs,SIZE,timeout)))//监听并判断是否有文件描述符属性发生改变
            //后三个参数为输出形,等文件描述符就位,返回0   -1    或着已就位的文件描述符的个数
    	    	{
    		        case 0: printf("timeout...\n");break;
    		        case -1:perror("epoll");break;
    		        default:
    			    {
    
    				    int i = 0;
    			        for(i=0;i<nums;i++)
    			        {
    				        int fd = revs[i].data.fd;//从就绪队列拿出已就绪好的fd
    
    
    					    if(fd == listen_sock && (revs[i].events &EPOLLIN))//检测监听套结字是否存在链接
                            {
                                //listen socket ready!
                                struct sockaddr_in client;//
                                socklen_t len = sizeof(client);
                                int rw_sock=accept(listen_sock,(struct sockaddr*)&client,&len) ;//客户端向服务器发出链接请求
                                //服务器利用accept()来接受请求,建立连接,并拿到客户端套结字
                                if(rw_sock <0)
                                {
                                    perror("accept failed");
                                    continue;
                                         
                                }
                                printf("get a new client :[%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));//输出客户端ip与端口号
                            
                                ev.events = EPOLLIN;//设置文件描述符为可读
                                ev.data.fd = rw_sock;//监听此套结字
                                epoll_ctl(epfd,EPOLL_CTL_ADD,rw_sock,&ev);//将拿到的套结字加入监听事件
                            }
                            else if(fd != listen_sock) //
                            {
                                    if(revs[i].events & EPOLLIN)//有数据来临时,(接收客户端数据)
                                    {
                                        //read ready
                                        char buf[1024];
                                        ssize_t s = read(fd,buf,sizeof(buf)-1);
                                        if(s>0) // read success
                                        {
                                            buf[s] = 0;
                                            printf("client#  %s\n",buf);//输出读的数据
    
                                            ev.events = EPOLLOUT;//重置事件为有数据要写
                                            ev.data.fd = fd;
                                            epoll_ctl(epfd,EPOLL_CTL_MOD,fd,&ev);
                                        }
                                        else if(s ==0)//没有读到数据
                                        {
                                            printf("client  is  quit!\n");
                                            close(fd);//关闭文件描述符
                                            epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);//删除
                                        }
                                        else
                                        {
                                            perror("read");
                                            close(fd);
                                            epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);
                                        }
                                    }
                                    else if(revs[i].events & EPOLLOUT)//有数据要写时
                                    {
                                        //write
                                        write(fd,msg,strlen(msg));//写msg内容
                                        close(fd);//关闭并删除
                                        epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);
                                    }
                            }
                        }
                    }
                }
            }
    
    
    
    
        return 0;    
    }
    
    
    
    从上面的调用方式就可以看到epoll比select/poll的优越之处:因为后者每次调用时都要传递你所要监控的所有socket给select/poll系统调用,这意味着需要将用户态的socket列表copy到内核态,如果以万计的句柄会导致每次都要copy几十几百KB的内存到内核态,非常低效。而我们调用epoll_wait时就相当于以往调用select/poll,但是这时却不用传递socket句柄给内核,因为内核已经在epoll_ctl中拿到了要监控的句柄列表。
    
    所以,实际上在你调用epoll_create后,内核就已经在内核态开始准备帮你存储要监控的句柄了,每次调用epoll_ctl只是在往内核的数据结构里塞入新的socket句柄。当epoll_wait调用时,仅仅观察这个list链表里有没有数据即可。有数据就返回,没有数据就sleep,等到timeout时间到后即使链表没数据也返回。所以,epoll_wait非常高效。
    

    epoll______LT(电平触发) 默认的,相当于高效的poll

    在事件就绪时,epoll_wait()会通知你,你可以不对此事件作出反应。
    当下次再调用epoll_wait()时,当你没有对此事作出反应时,还用通知你
    

    ET(边缘触发)epoll的高效工作模式,(需向epoll内核事件表中注册一fd上的EPOLLET事件)

    当事件就绪,epoll_wait()通知你,你必须处理此事件,因为下次不会再通知你
    

    三种I/O复用区别:
    从原理上看:
    select 与poll都是采用了轮询方式去访问文件描述符集,每次返回准备就绪的一个,时间复杂度为O(n),epoll_wait()采用回调方式,当检测到有就绪描述符时,会触发回调函数,将就绪描述符加载到就绪队列中,内核会在合适的时机将事件拷贝到用户空间,时间复杂度为O(1)
    从内存消耗:
    select/poll将所监控的文件描述符从用户态copy到内核态,切换频率高,效率低下
    文件描述符上限
    epoll几乎没有上限(与内存有关)

    展开全文
  • select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。 select:该函数允许进程指示内核等待多个事件中的任何一个发生,并只在有一个或多个事件发生或经历一段指定的时间后才唤醒它。 参数意义: nfds:...
  • 普通的4C8G独立MySQL数据库,经测试可能承受2K-3K的并发读写,测试中也有很多因素影响,服务器硬盘是机械或者SSD,linux系统的IO调度算法,最大文件句柄数,Buffer Pool调优,数据库中的表,行溢出......
  • 用TCP/IP进行网际互联第三卷:客户-服务器编程与应用(Linux/POSIX套接字版) 基本信息 原书名:Internetworking With TCP/IP Vol Ⅲ:Client-Server Programming And Applications Linux/POSIX Sockets V 作者: ...
  • python实现高并发

    2019-05-23 00:25:00
    理论方法 基于IO多路复用,windows中使用...Linux中使用select最多能监听1024个文件句柄,使用轮询检测;pool,监听个数不限制;epoll使用边缘触发,回调通知 IO多路复用-扩展知识 官方定义:帮助开发者监听多个I...
  • 基于Reactor模式实现的I/O框架库包含了如下几个组件: 句柄(Handler) ...事件多路分发器(EventDemultiplexer) ... 句柄 ...作用:当内核检测到就绪事件时,它将通过句柄来...在Linux下,I/O事件对应的句柄文件描...
  • 健康检测服务:支持通过配置文件限制应用程序占用内存、线程数、句柄数,超限制重启整个服务进程。 定时服务:支持通过配置文件指定应用程序定时重启。 镜像服务:支持通过配置文件修改服务名,使.
  • 糖果的软件

    2014-08-03 20:08:35
    要解决上述问题,需要确定拥有文件打开句柄的进程,然后关闭此进程。 在以前的 Windows 中,我们可以使用资源工具包的 Oh.exe 。但在 XP 中,安装 好的 Support Tools 却不带 Oh.exe 。不过, XP 提供了一个新的...
  •  注意:该事件在Linux版本的Flash Player中存在问题,目前还无法解决。  - 传入参数  file object:文件对象  bytes complete:已经上传完毕的文件字节数  total bytes:文件总体积的字节数 [编辑本段]常见错误...
  • 支持编译生成独立的非插件形式的动态库文件,体积小,比如嵌入式linux不支持designer只需要动态库的形式。 每个控件都有一个单独的完整的使用demo,方便参考学习单个控件使用,非常适合初学者。 提供一个所有控件...
  • Shell脚本专家指南

    2011-04-29 13:06:49
    9.3 访问用户指定的文件句柄 9.4 从shell中访问描述符 第10章 管道输入读 10.1 逐行选项1 10.2 逐行选项2 10.3 逐行选项3 10.4 逐行选项4 10.5 直接管道读 10.6 逐字处理输入 第2部分 系统交互与高级技术 第11章 ...
  • Foxpro 开发答疑160问

    2014-10-07 19:55:45
    69. 如何进行DOS/Windows文本文件与UNIX/Linux文本文件的相互转换 257 70. 如何遍历磁盘中的所有目录及文件 258 71. 如何使用低级函数读写文件 263 72. 如何为Visual FoxPro应用程序增加文件压缩功能 271 73. ...
  • Tinyxml 源代码(VC6 & VS2005)

    热门讨论 2009-08-12 15:57:04
    提供了一个Linux Makefile和一个Windows Visual C++ .dsw 文件。只需要简单地编译和运行,它就会在你的磁盘上生成demotest.xml文件并在屏幕上输出。它还尝试用不同的方法遍历DOM并打印出结点数。 那个Linux ...
  • Android 一种基于Linux的自由及开放源代码的操作系统,主要使用于移动设备,如智能手机和平板电脑,由Google公司和开放手机联盟领导开发 IOS 由苹果公司开发的移动操作系统 Webkit 一个开源的浏览器引擎,在手机上的...
  • 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中追加数据,如何使用二进制文件,如何获得 对文件的随机...
  • 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中追加数据,如何使用二进制文件,如何获得 对文件的随机...
  • 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中追加数据,如何使用二进制文件,如何获得 对文件的随机...
  • 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中追加数据,如何使用二进制文件,如何获得 对文件的随机...
  • 利用sysctl函数查看当前进程信息,判断是否有此标志位来检测是否处理调试状态)、反反调试、反注入(通过_dyld_get_image_name()获取加载的模块名,判断是否都在白名单中)、hook检测(通过dladdr函数得到imp地址所在的...
  • 10.5.4 用单步中断检测SoftICE 334 10.5.5 陷阱标志 335 10.5.6 代码校验和 335 10.6 迷惑反汇编器 336 10.6.1 线性扫描反汇编器 337 10.6.2 递归遍历反汇编器 338 10.6.3 应用 343 10.7 代码混淆 344 10.8 控制流变...
  • Reversing:逆向工程揭密

    热门讨论 2010-06-21 17:27:22
    10.5.4 用单步中断检测SoftICE 334 10.5.5 陷阱标志 335 10.5.6 代码校验和 335 10.6 迷惑反汇编器 336 10.6.1 线性扫描反汇编器 337 10.6.2 递归遍历反汇编器 338 10.6.3 应用 343 10.7 代码混淆 344 10.8 控制流变...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

linux检测文件句柄

linux 订阅