精华内容
下载资源
问答
  • java阻塞阻塞

    2014-01-02 11:13:21
    JAVA IO的各种流是阻塞的,这意味着,当一个线程调用read()或write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。 该线程在此期间不能再干任何事情了。   阻塞式网络 IO 的特点:多线程处理多个...

    阻塞与非阻塞IO

    JAVA IO的各种流是阻塞的,这意味着,当一个线程调用read()或write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。

    该线程在此期间不能再干任何事情了。

     

    阻塞式网络 IO 的特点:多线程处理多个连接。每个线程拥有自己的栈空间并且占用一些 CPU 时间。每个线程遇到外部未准备好的时候,都会阻塞掉。

    阻塞的结果就是会带来大量的进程上下文切换。且大部分进程上下文切换可能是无意义的。比如假设一个线程监听一个端口,一天只会有几次请求进来,

    但是该 cpu 不得不为该线程不断做上下文切换尝试,大部分的切换以阻塞告终。

     

    一辆从 A 开往 B 的公共汽车上,路上有很多点可能会有人下车。司机不知道哪些点会有哪些人会下车,对于需要下车的人,如何处理更好?

    1. 司机过程中定时询问每个乘客是否到达目的地,若有人说到了,那么司机停车,乘客下车。 ( 类似阻塞式 )

    2. 每个人告诉售票员自己的目的地,然后睡觉,司机只和售票员交互,到了某个点由售票员通知乘客下车。 ( 类似非阻塞 )

    很显然,每个人要到达某个目的地可以认为是一个线程,司机可以认为是 CPU 。在阻塞式里面,每个线程需要不断的轮询,上下文切换,以达到找到目的地的结果。

    而在非阻塞方式里,每个乘客 ( 线程 ) 都在睡觉 ( 休眠 ) ,只在真正外部环境准备好了才唤醒,这样的唤醒肯定不会阻塞。

      非阻塞的原理

    把整个过程切换成小的任务,通过任务间协作完成。

    由一个专门的线程来处理所有的 IO 事件,并负责分发。

    事件驱动机制:事件到的时候触发,而不是同步的去监视事件。

    线程通讯:线程之间通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的进程切换。

    简单的说:创建专门的线程来处理所有IO事件,并负责分发。(就是售票员,司机只和售票员交互,司机CPU)

    使用wait() notify()来进行线程的切换,保证每次上下文切换都是有意义的。

    以下是异步 IO 的结构:

    Reactor 就是上面隐喻的售票员角色。每个线程的处理流程大概都是读取数据、解码、计算处理、编码、发送响应。

    非阻塞的优势:减少了CPU线程切换的开销,减少了N个请求对应N个线程的阻塞资源(阻塞会一直轮询)

    展开全文
  • 这就意味着当发出一个不能立即完成的套接字调用时,其进程投入睡眠,等待相应操作完成 可能阻塞的套接字调用可以分为以下4类型 (1) 输入操作,包括read、readv、recv、recvfrom和recvmsg共5个函数。如果某个...

    一、阻塞IO分类

    • 套接字的默认状态是阻塞的。这就意味着当发出一个不能立即完成的套接字调用时,其进程将被投入睡眠,等待相应操作完成

    可能阻塞的套接字调用可以分为以下4类型

    • (1) 输入操作,包括read、readv、recv、recvfrom和recvmsg共5个函数。如果某个进程 对一个阻塞的TCP套接字(默认设置)调用这些输入函数之一,而且该套接字的接收缓冲区中 没有数据可读,该进程将被投入睡眠,直到有一些数据到达。既然TCP是字节流协议,该进程 的唤醒就是只要有一些数据到达,这些数据既可能是单个字节,也可以是一个完整的TCP分节 中的数据。如果想等到某个固定数目的数据可读为止,那么可以调用我们的readn函数(图3-15), 或者指定MSG_WAITALL标志(图14-6)
      • 既然UDP是数据报协议,如果一个阻塞的UDP套接字的接收缓冲区为空,对它调用输入函 数的进程将被投入睡眠,直到有UDP数据报到达
      • 对于非阻塞的套接字,如果输入操作不能被满足(对于TCP套接字即至少有一个字节的数 据可读,对于UDP套接字即有一个完整的数据报可读),相应调用将立即返回一个EWOULDBLOCK 错误
    • (2) 输出操作,包括write、writev、send、sendto和sendmsg共5个函数。对于一个TCP 套接字我们已在2.11节说过,内核将从应用进程的缓冲区到该套接字的发送缓冲区复制数据。 对于阻塞的套接字,如果其发送缓冲区中没有空间,进程将被投入睡眠,直到有空间为止。
      • 对于一个非阻塞的TCP套接字,如果其发送缓冲区中根本没有空间,输出函数调用将立即 返回一个EWOULDBLOCK错误。如果其发送缓冲区中有一些空间,返回值将是内核能够复制到该 缓冲区中的字节数。这个字节数也称为不足计数(short count)。
      • 我们还在2.11节说过,UDP套接字不存在真正的发送缓冲区。内核只是复制应用进程数据 并把它沿协议栈向下传送,渐次冠以UDP首部和IP首部。因此对一个阻塞的UDP套接字(默认 设置),输出函数调用将不会因与TCP套接字一样的原因而阻塞,不过有可能会因其他的原因而 阻塞
    • (3) 接受外来连接,即accept函数。如果对一个阻塞的套接字调用accept函数,并且尚无 新的连接到达,调用进程将被投入睡眠。
      • 如果对一个非阻塞的套接字调用accept函数,并且尚无新的连接到达,accept调用将立即 返回一个EWOULDBLOCK错误。
    • (4) 发起外出连接,即用于TCP的connect函数。(回顾一下,我们知道connect同样可用于 UDP,不过它不能使一个“真正”的连接建立起来,它只是使内核保存对端的IP地址和端口号。) 我们已在2.6节展示过,TCP连接的建立涉及一个三路握手过程,而且connect函数一直要等到 客户收到对于自己的SYN的ACK为止才返回。这意味着TCP的每个connect总会阻塞其调用进程至少一个到服务器的RTT时间
      • 如果对一个非阻塞的TCP套接字调用connect,并且连接不能立即建立,那么连接的建立 能照样发起(譬如送出TCP三路握手的第一个分组),不过会返回一个EINPROGRESS错误。注意 这个错误不同于上述三个情形中返回的错误。另请注意有些连接可以立即建立,通常发生在服 务器和客户处于同一个主机的情况下。因此即使对于一个非阻塞的connect,我们也得预备 connect成功返回的情况发生。我们将在16.3节展示一个非阻塞connect的例子
    • 注意事项:按照传统,对于不能被满足的非阻塞式I/O操作,System V会返回EAGAIN错误,而源自 Berkeley的实现则返回EWOULDBLOCK错误。顾及历史原因,POSIX规范声称这种情况下这两 个错误码都可以返回。幸运的是,大多数当前的系统把这两个错误码定义成相同的值(检查 一下你自己的系统中的头文件),因此具体使用哪一个并无多大关系。我们 在本书中使用EWOULDBLOCK

    二、非阻塞读写案例

    案例简介

    • 我们再次回到前面讨论过的str_cli函数。前面使用的select的版本仍使用阻塞式I/O。举例来说,如果在标准输入有一行文本可读,我们就调用read读入它,再调用 writen把它发送给服务器。然而如果套接字发送缓冲区已满,writen调用将会阻塞。在进程阻 塞于writen调用期间,可能有来自套接字接收缓冲区的数据可供读取。类似地,如果从套接字 中有一行输入文本可读,那么一旦标准输出比网络还要慢,进程照样可能阻塞于后续的write 调用。本节的目标是开发这个函数的一个使用非阻塞式I/O的版本。这样可以防止进程在可做任 何有效工作期间发生阻塞。
    • 不幸的是,非阻塞式I/O的加入让本函数的缓冲区管理显著地复杂化了,因此我们将分片介 绍这个函数。我们已在第6章和第14章中讨论过在套接字上使用标准I/O的潜在问题和困难,它 们在非阻塞式I/O操作中显得尤为突出。本例子中继续避免使用标准I/O
    • 我们维护着两个缓冲区:to容纳从标准输入到服务器去的数据,fr容纳自服务器到标准输 出来的数据。下图展示了to缓冲区的组织和指向该缓冲区中的指针

    • 其中toiptr指针指向从标准输入读入的数据可以存放的下一个字节。tooptr指向下一个必须写到套接字的字节。有(toiptr -tooptr)个字节需写到套接字。可从标准输入读入的字节 数是(&to[MAXLINE]- toiptr)。一旦tooptr移动到toiptr,这两个指针就一起恢复到缓冲 区开始处
    • 下图展示了fr缓冲区相应的组织

    源码

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<errno.h>
    #include<sys/socket.h>
    #include<sys/select.h>
    #include<unistd.h>
    #include<fcntl.h>
    #include<sys/time.h>
    #include<sys/types.h>
    #include<arpa/inet.h>
    #include<netinet/in.h>
    
    #define MAXLINE 1024
    int max(int f1,int f2);
    void str_cli(FILE *fp,int sockfd);
    char *gf_time(void);
    
    int main(int argc,char *argv[])
    {
        if(argc!=3){
            perror("please enter [IP] [PORT]");
            exit(EXIT_FAILURE);
        }
    
        int sockFd=socket(AF_INET,SOCK_STREAM,0);
        if(sockFd<0){
            perror("socket");
            exit(EXIT_FAILURE);
        }
    
        struct sockaddr_in serverAddr;
        serverAddr.sin_family=AF_INET;
        serverAddr.sin_port=htons(atoi(argv[2]));
        if((inet_aton(argv[1],(struct in_addr*)&serverAddr.sin_addr))==0){
            perror("inet_aton");
            exit(EXIT_FAILURE);
        }
    
        if(connect(sockFd,(struct sockaddr*)&serverAddr,sizeof(serverAddr))<0){
            printf("Connect failed,reasons:%s\n",strerror(errno));
            close(sockFd);
            exit(EXIT_FAILURE);
        }
     
        printf("Connect success\n");
    
        str_cli(stdin,sockFd);
    
        exit(0);
    }
    
    void str_cli(FILE *fp,int sockfd)
    {
        int maxfdp1,val,stdineof,retval;
        ssize_t n,nwritten;
        fd_set rset,wset;
        char to[MAXLINE],fr[MAXLINE]; //to存放标准输入,fr存放标准输出
        char *toiptr,*tooptr,*friptr,*froptr;
    
        val=fcntl(sockfd,F_GETFL,0);
        fcntl(sockfd,F_SETFL,val | O_NONBLOCK);//把sockfd设为非阻塞
    
        val=fcntl(STDIN_FILENO,F_GETFL,0);
        fcntl(STDIN_FILENO,F_SETFL,val | O_NONBLOCK);//把标准输入设为非阻塞
    
        val=fcntl(STDOUT_FILENO,F_GETFL,0);
        fcntl(STDOUT_FILENO,F_SETFL,val | O_NONBLOCK);//把标准输出设为非阻塞
    
        toiptr=tooptr=to;
        friptr=froptr=fr;
        stdineof=0;
    
        maxfdp1=max(max(STDIN_FILENO,STDOUT_FILENO),sockfd)+1;
        for(;;){
            FD_ZERO(&rset);
            FD_ZERO(&wset);
            if(stdineof==0 && toiptr<&to[MAXLINE])//如果标准输入还可以存放数据
                FD_SET(STDIN_FILENO,&rset);
            if(friptr<&fr[MAXLINE])
                FD_SET(sockfd,&rset);
            if(tooptr!=toiptr)
                FD_SET(sockfd,&wset);
            if(froptr!=friptr)
                FD_SET(STDOUT_FILENO,&wset);
            switch(retval=select(maxfdp1,&rset,&wset,NULL,NULL))
            {
                case -1:
                    perror("select");
                    continue;
                case 0:
                    printf("timeout\n");
                    continue;
                default:
                    if(FD_ISSET(STDIN_FILENO,&rset))//从标准输入读取数据
                    {
                        if((n=read(STDIN_FILENO,toiptr,&to[MAXLINE]-toiptr))<0){
                            if(errno!=EWOULDBLOCK)
                                perror("read error on stdin");
                        }else if(n==0){
                            fprintf(stderr,"%s:EOF on stdin\n",gf_time());
                            stdineof=-1;
                            if(tooptr==toiptr)//关闭写端
                                shutdown(sockfd,SHUT_WR);
                        }else{
                            fprintf(stderr,"%s:read %d bytes from stdin\n",gf_time(),n);
                            toiptr+=n;
                            FD_SET(sockfd,&wset);
                        }
                    }
    
                    if(FD_ISSET(sockfd,&rset))
                    {
                        if((n=read(sockfd,friptr,&fr[MAXLINE]-friptr))<0){
                            if(errno!=EWOULDBLOCK)
                                perror("read error on socket");
                        }else if(n==0){
                            fprintf(stderr,"%s:EOF on socket\n",gf_time());
                            if(stdineof)
                                return;
                            else
                                perror("str_cli:server terinated prematurely");
                        }else{
                            fprintf(stderr,"%s:read %d bytes from socket\n",gf_time(),n);
                            friptr+=n;
                            FD_SET(STDOUT_FILENO,&wset);
                        }
                    }
    
                    if(FD_ISSET(STDOUT_FILENO,&wset)&&((n=friptr-froptr)>0))
                    {
                        if((nwritten=write(STDOUT_FILENO,froptr,n))<0){
                            if(errno!=EWOULDBLOCK)
                                perror("write error to stdout");
                        }else{
                            fprintf(stderr,"%s:wrote %d bytes to stdout\n",gf_time(),nwritten);
                            froptr+=nwritten;
                            if(froptr==friptr)
                                froptr=friptr=fr;
                        }
                    }
    
                    if(FD_ISSET(sockfd,&wset)&&((n=toiptr-tooptr)>0))
                    {
                        if((nwritten=write(sockfd,tooptr,n))<0){
                            if(errno!=EWOULDBLOCK)
                                perror("write error to socket");
                        }else{
                            fprintf(stderr,"%s:wrote %d bytes to socket\n",gf_time(),nwritten);
                            froptr+=nwritten;
                            if(tooptr==toiptr)
                                toiptr=tooptr=to;
                            if(stdineof)
                                shutdozwn(sockfd,SHUT_WR);
                        }
                    }
                    break;
            }
            
        }
    }
    
    int max(int f1,int f2)
    {
        if(f1>f2)
            return f1;
        else if(f1<f2)
            return f2;
        else
            return f1;
    }
    
    char *gf_time(void)
    {
        struct timeval tv;
        static char str[30];
        char *ptr;
        if(gettimeofday(&tv,NULL)<0)
            perror("gettimeofday");
        ptr=ctime(&tv.tv_sec);
        strcpy(str,&ptr[11]);
        snprintf(str+8,sizeof(str)-8,
    
    ".%06ld",tv.tv_usec);
        return (str);
    }
    
    
    展开全文
  • 阻塞IO

    2014-04-22 20:39:17
    这一点意味着当发出一个不能立即完成的套接口调用时,其进程投入睡眠,等待响应操作完成。 1.输入操作:read、readv、recvfrom。 如果某个进程一个阻塞的TCP套接口调用这些函数之一,而且该套接口的接收缓冲...

    套接口缺省是阻塞的。这一点意味着当发出一个不能立即完成的套接口调用时,其进程将被投入睡眠,等待响应操作完成。

    1.输入操作:read、readv、recvfrom。

    如果某个进程对一个阻塞的TCP套接口调用这些函数之一,而且该套接口的接收缓冲区中没有数据可读,该进程将投入睡眠,直到一些数据到达。既然TCP是字节流协议,该进程的唤醒就只需到达一些数据:这些数据可能是单个字节,也可以是一个完整的TCP分节中的数据。如果想等到某个固定数目的数据可读为止,那么可以调用我们的readn函数,或者指定MSG_WAITALL标志。UDP是数据报协议,如果一个阻塞的UDP套接口的接收缓冲区为空,对他调用输入函数的进程将睡眠,直到到达一个完整的UDP数据报。

    对于非阻塞的套接口,如果输入操作不能被满足(TCP套接口即至少有一个字节的数据可读,对于UDP套接口即有一个完整的数据报可读),相应调用立即返回一个EWOULDBLOCK错误。


    2.输出操作:write,writev,send,sendto等

    对于TCP套接口,内核将从应用进程的缓冲区拷贝数据到套接口的发送缓冲区。对于阻塞的套接口,如果其发送缓冲区没有空间,进程将被投入睡眠,直至有空间为止。

    对于一个非阻塞的TCP套接口,如果其发送缓冲区中根本没有空间,输出函数调用将立即返回一个EWOULDBLOCK错误。如果其发送缓冲区有一些空间,返回值将是内核能够拷贝到改缓冲区中的字节数。

    UDP套接口不存在真正的发送缓冲区,内核只是拷贝应用进程数据并把它沿着协议栈向下传送,渐次冠以UDP头部和IP头部,因此对一个非阻塞UDP套接口,输出函数不会因与TCP套接口一样的原因阻塞,不过可能因其他原因阻塞。


    3.accept

    阻塞:无连接到达,进程睡眠

    非阻塞:如果对一个非阻塞的套接口调用accept函数,并且尚无新的链接到达,accept调用将立即返回EWOULDBLOCK错误


    4.connect

    如果对一个非阻塞的TCP套接口调用connect,并且连接不能立即建立,那么连接的建立照样发起(譬如发送三次握手的第一个分组),不过返回一个EINPROGRESS错误。注意这个错误不同于上述三种情况的错误。另请注意有些连接可以立即建立,这主要发送在服务器和客户机在同一个机器的情况。因此对一个非阻塞的connect,我们也得预备connect成功返回情况发生。


    展开全文
  • 这就意味着当发出一个不能立即完成的套接字调用时,其进程投入睡眠,等待相应的操作完成。可能阻塞的套接字调用可分为以下4类:(1)输入操作,包括read,readv,recv,recvfrom和recvmsg共5个函数。如果某个...

         套接字的默认状态是阻塞的。这就意味着当发出一个不能立即完成的套接字调用时,其进程将被投入睡眠,等待相应的操作完成。可能阻塞的套接字调用可分为以下4类:

    (1)输入操作,包括read,readv,recv,recvfrom和recvmsg共5个函数。如果某个进程对一个阻塞的TCP套接字(默认设置)调用这些输入函数之一,而且该套接字的接收缓冲区中没有数据可读,该进程将被投入睡眠,直到有一些数据到达。既然TCP是字节流协议,该进程的唤醒就是只要有一些数据到达,这些数据既可能是单个字节,也可能是一个完整的TCP分节中的数据。

          既然UDP是数据报协议,如果一个阻塞的UDP套接字的接收缓冲区为空,对它调用输入函数的进程将被投入睡眠,直到有UDP数据报到达。

          对于非阻塞的套接字,如果输入操作不能被满足(对于TCP套接字即至少有一个字节的数据报可读,对于UDP套接字即有一个完整的数据报可读),相应调用将立即返回一个EWOULDBLOCK错误


    (2)输出操作,包括write,writev,send,sento和sendmsg共5个函数。对于一个TCP套接字,内核将从应用进程的缓冲区到该套接字的发送缓冲区复制数据。对于阻塞的套接字,如果其发送缓冲区中没有空间,进程将被投入睡眠,直到有空间为止。

         对于一个非阻塞的TCP套接字,如果其发送缓冲区中根本没有空间,输出函数调用将立即返回一个EWOULDBLOCK错误如果其发送缓冲区中有一些空间,返回值将是内核能够复制到该缓冲区中的字节数。

         UDP套接字不存在真正的发送缓冲区。内核只是复制应用进程数据并把它沿协议栈向下传送,渐次冠以UDP首部和IP首部。因此对一个阻塞的UDP套接字(默认设置),输出函数调用将不会因与TCP套接字一样的原因而阻塞,不过有可能会因为其他的原因而阻塞。


    (3)接受外来连接,即accept函数。如果对一个阻塞的套接字调用accept函数,并且尚无新的连接到达,调用进程将被投入睡眠。

          如果对一个非阻塞的套接字调用accept函数,并且尚无新的连接到达,accept调用将立即返回一个EWOULDBLOCK错误


    (4)发起外出连接,即用于TCP的connect函数。TCP连接的建立涉及一个三次握手过程,而且connect函数一直等到客户收到自己的SYN的ACK为止才返回。这意味着TCP的每个connect总是阻塞其调用进程至少一个到服务器的RTT时间。

          如果对一个非阻塞的TCP套接字调用connect,并且连接不能立即建立,那么连接的建立能照样发起(譬如送出TCP三次握手的第一个分组),不过会返回一个EINPROGRESS错误。注意这个错误不同于上述三个情形中的返回的错误。

     

     

    下面该函数使用fork把当前进程划分成两个进程。

         这个函数一开始就调用fork把当前进程划分成一个父进程和一个子进程。子进程把来自服务器的文本行复制到标准输出,父进程把来自标准输入的文本行复制到服务器。

                            

    void
    str_cli(FILE *fp, int sockfd)
    {
    	pid_t	pid;
    	char	sendline[MAXLINE], recvline[MAXLINE];
    
    	if ( (pid = fork()) == 0) {		/* child: server -> stdout */
    		while (read(sockfd, recvline, MAXLINE) > 0)
    			fputs(recvline, stdout);
    
    		kill(getppid(), SIGTERM);	/* in case parent still running */
    		exit(0);
    	}
    
    		/* parent: stdin -> server */
    	while (fgets(sendline, MAXLINE, fp) != NULL)
    		writen(sockfd, sendline, strlen(sendline));
    
    	shutdown(sockfd, SHUT_WR);	/* EOF on stdin, send FIN */
    	pause();
    	return;
    }

         我们知道TCP连接是全双工的,而且父子进程共享同一个套接字:父进程往该套接字中写,子进程从该套接字中读。尽管套接字只有一个,其接收缓冲区和发送缓冲区也分别只有一个,然而这个套接字却有两个描述符在引用它:一个在父进程中,另一个在子进程中。

         我们同样需要考虑进程终止序列。正常的终止序列从标准输入上遇到EOF之时开始发生。父进程读入来自标准输入的EOF后调用shutdown发送FIN。但当这发生之后,子进程需继续从服务器到标准输出执行数据复制,直到在套接字上读到EOF。

         服务器进程过早终止也有可能发生。要是发生这种情况,子进程将在套接字上读到EOF。这样的子进程必须告知父进程停止从标准输入到套接字复制数据。子进程向父进程发送一个SIGTERM信号,以防止父进程仍在运行。如此处理的另一个手段是子进程无为的终止,使得父进程(如果仍在运行的话)捕获一个SIGCHLD信号。

         父进程完成数据复制后调用pause让自己进入睡眠状态,直到捕获一个信号(子进程来的SIGTERM信号),尽管它不主动捕获任何信号。SIGTERM信号的默认行为是终止进程。




    展开全文
  • linux 阻塞等待

    千次阅读 2012-09-07 14:45:45
    一个进程被置为睡眠, 它被标识为处于一个特殊的状态并且从调度器的运行队列中去除. 直到发生某些事情改变了那个状态, 这个进程将不被在任何 CPU 上调度, 并且, 因此, 将不会运行. 一个睡着的进程已被搁置到系统的...
  • 套接字默认状态是阻塞的,这就意味着当发出一个不能立刻完成的套接字调用时,其进程投入睡眠,等待相应操作完成。 可能阻塞的套接字调用可分为四类: (1)输入操作:read,readv,recv,recvfrom,recvmsg,如果某个进程...
  • 阻塞式socket

    千次阅读 2018-04-14 15:40:17
    这就意味着当发出一个不能立即完成的套接字调用时,其进 程将投入睡眠,等待相应操作完成。可能阻塞的套接字调用可分为以下四类: ( 1 ) 输入操作,包括read 、 readv、 recv、 recvfrom和 recvmsg共5个函数。...
  • 阻塞式I/O

    2020-01-23 21:49:06
    这就意味着当发出一个不能立即完成的套接字调用时,其进程投入睡眠,等待响应操作完成。可能阻塞的套接字调用可分为以下四类: 输入操作,包括read、readv、recv、recvfrom和recvmsg共5个函数。如果某个进程对...
  • 第十六章非阻塞式IO

    2019-01-07 09:01:31
    意味着当发生一个不能立即完成的套接字调用的时候,其进程将会投入睡眠,等待相应操作完成。可能阻塞的套接字分为以下四类。 (1)输入的操作,包括read、readv、recv、recvfrom和recvmsg这5个函数,如果某进程...
  • 挂起:由于系统和用户的需要引入了挂起的操作,进程被挂起意味着该进程处于静止状态。如果进程正在执行,它将暂停执行,若原本处于就绪状态,则该进程此时暂不接受调度。 共同点: 都导致进程暂停执行。 进程都释放...
  • 阻塞I/O

    2013-04-28 13:33:00
    这一点意味着当发出一个不能立即完成的套接口调用时,其进程投入睡眠,等待相应操作完成。可能阻塞的套接口调用可分为一下四类。 1 输入操作:包括read, readv, recv, recvfrom和recvmsg共5个函数。如果某个...
  • TCP非阻塞设置

    千次阅读 2018-05-03 17:21:03
    套接字的默认状态是阻塞的,这就意味着当发出一个不能立即完成的套接字调用时,其进程投入睡眠,等待响应操作完成,可能阻塞的套接字调用可分为以下四类:(1) 输入操作,包括read,readv,recv,recvfrom,...
  • UNP学习 非阻塞I/O

    2018-03-09 14:54:00
    意味着一个套接口调用不能立即完成时,进程进入睡眠状态,等待操作完成。我们将可能阻塞的套接口调用分成四种。 1.输入操作:read、readv、recv、recvfrom和recvmsg函数。TCP时一个字节流,数据到来前一直会...
  • 阻塞和挂起是操作系统的进程的状态描述,容易...挂起:由于系统和用户的需要引入了挂起的操作,进程被挂起意味着该进程处于静止状态。如果进程正在执行,它将暂停执行,若原本处于就绪状态,则该进程此时暂不接受...
  • 阻塞 VS 挂起 阻塞与挂起都是进程的状态,但他们有一些相似之处,也有一些区别,下面先对他们进行概述,再进行比较 ...挂起:由于系统和用户的需要引入了挂起的操作,进程被挂起意味着该进程处于静止状态。如果进...
  • 阻塞套接字意味着当发出一个不能立即完成的套接字调用时,其进程将投入睡眠,等待相应操作完成。非阻塞套接字,如果输入操作不能满足(对于tcp套接字即至少有一个字节的数据可读,对于udp套接字即有一个完整的数据...
  • 套接字的默认状态是阻塞的,这就意味着当发出一个不能立即完成的套接字调用时,其进程投入睡眠,等待响应操作完成,可能阻塞的套接字调用可分为以下四类: (1) 输入操作,包括read,readv,recv,recvfrom,...
  • 如果有一个事务或语句被阻塞,就意味着它在等待资源上的锁被释放。下面说明SET LOCK TIMEOUT选项,它指定了阻塞的进程语句在返回错误之前碰该等待多少时间来释放锁。 语法如下: SET LOCK TlMEOUT timeout_period ...
  • UNIX网络编程----非阻塞式I/O(十六)

    千次阅读 2013-09-13 13:55:54
    这就意味着放发出一个不能立即完成的套接字调用时,其进程被投入睡眠,等待相应操作完成,可能阻塞的套接字调用可分为以下四类: 1) 输入操作:包括read、readv、readmsg、readfrom、recv共5个函数。如果某个进程...
  • 原因是,事实上,大多数浏览器使用单进程处理UI和更新Javascript运行等多个任务,而同一时间只能有一个任务执行。Javascript运行了多长时间,那么在浏览器空闲下来响应用户交互之前的等待时间就有多长。 从基本...
  • 原因是,事实上,大多数浏览器使用单进程处理UI和更新Javascript运行等多个任务,而同一时间只能有一个任务执行。Javascript运行了多长时间,那么在浏览器空闲下来响应用户交互之前的等待时间就有多长。 从基本...
  • 1.休眠进程被置为休眠,意味着它被标识为处于一个特殊的状态并且从调度器的运行队列中移走。这个进程将不被在任何 CPU 上调度,即将不会运行。 直到发生某些事情改变了那个状态。安全地进入休眠的两条规则:(1)...
  • Linux设备驱动程序学习(5) ...进程被置为休眠,意味着它被标识为处于一个特殊的状态并且从调度器的运行队列中移走。这个进程将不被在任何 CPU 上调度,即将不会运行。 直到发生某些事情改变了那个状态。安全地
  • (65865346)     一、休眠 进程被置为休眠,意味着它被标识为处于一个特殊的状态并且从调度器的运行队列中移走。这个进程将不被在任何 CPU 上调度,即将不会运行。 直到发生某些事情改变了...

空空如也

空空如也

1 2 3 4 5 6
收藏数 114
精华内容 45
关键字:

一个进程被阻塞意味着