2015-09-28 23:50:23 u011135852 阅读数 2810

阻塞和非阻塞

  • 读常规文件是不会阻塞的,不管读多少字节,read一定会在有限的时间内返回。从终端设备或网络读则不一定,如果从终端输入的数据没有换行符,调用read读终端设备就会阻塞,如果网络上没有接收到数据包,调用read从网络读就会阻塞,至于会阻塞多长时间也是不确定的,如果一直没有数据到达就一直阻塞在那里。同样,写常规文件是不会阻塞的,而向终端设备或网络写则不一定。


  • 现在明确一下阻塞(Block)这个概念。当进程调用一个阻塞的系统函数时,该进程被置于睡眠(Sleep)状态,这时内核调度其它进程运行,直到该进程等待的事件发生了(比如网络上接收到数据包,或者调用sleep指定的睡眠时间到了)它才有可能继续运行。与睡眠状态相对的是运行(Running)状态,在Linux内核中,处于运行状态的进程分为两种情况:
    正在被调度执行。CPU处于该进程的上下文环境中,程序计数器(eip)里保存着该进程的指令地址,通用寄存器里保存着该进程运算过程的中间结果,正在执行该进程的指令,正在读写该进程的地址空间。


  • 就绪状态。该进程不需要等待什么事件发生,随时都可以执行,但CPU暂时还在执行另一个进程,所以该进程在一个就绪队列中等待被内核调度。系统中可能同时有多个就绪的进程,那么该调度谁执行呢?内核的调度算法是基于优先级和时间片的,而且会根据每个进程的运行情况动态调整它的优先级和时间片,让每个进程都能比较公平地得到机会执行,同时要兼顾用户体验,不能让和用户交互的进程响应太慢。

阻塞读终端

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

int main(void)
{
        char buf[10] = {0};
        int n = 0;
        n = read(STDIN_FILENO, buf, 10);
        if (n < 0)
        {
                perror("read STDIN_FILENO");
        }
        write(STDOUT_FILENO, buf, n);
        printf("\n");
        return 0;
}

非阻塞读终端

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define MSG_AGN "try again\n"

int main(void)
{
        char buf[10] = {0};
        int n = 0;
        int fd = 0;
        fd = open("/dev/tty", O_RDONLY | O_NONBLOCK);
        if (fd < 0)
        {
                perror("open /dev/tty");
                exit(1);
        }
tryagain:
        n = read(fd, buf, 10);
        if (n < 0)
        {
                if (errno == EAGAIN)
                {
                        sleep(5);
                        write(STDOUT_FILENO, MSG_AGN, strlen(MSG_AGN));
                        goto tryagain;
                }
                perror("read /dev/tty");
                exit(1);
        }
        write(STDOUT_FILENO, buf, n);
        printf("\n");
        close(fd);
        return 0;
}

非阻塞读终端和超时等待

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define MSG_AGN "try again\n"
#define MSG_TIMEOUT "time out\n"

int main(void)
{
        char buf[10] = {0}; 
        int n = 0,fd = 0;
        int i = 0;
        fd = open("/dev/tty", O_RDONLY | O_NONBLOCK);
        if (fd < 0)
        {
                perror("open /dev/tty");
                exit(1);
        }
        for (i = 0; i<5; i++)
        {

                n = read(fd, buf, 10);
                if (n >= 0)
                {
                        break;
                }

                if (errno != EAGAIN)
                {

                        perror("read /dev/tty");
                        exit(1);
                }

                sleep(1);
            write(STDOUT_FILENO, MSG_AGN, strlen(MSG_AGN));
        }
        if (i == 5)
                write(STDOUT_FILENO, MSG_TIMEOUT, strlen(MSG_TIMEOUT));
                else
                        write(STDOUT_FILENO, buf, n);
        printf("\n");
        close(fd);
        return 0;
}
2013-09-25 14:27:53 zagfai 阅读数 2758

    很久很久以前,系windows平台下,用C语言写过一款贪食蛇游戏,cmd界面,用kbhit()函数实现非阻塞输入。系windows平台下用python依然可以调用msvcrt.khbit实现非阻塞监听。但系喺linux下面就冇呢支歌仔唱。

    随手google咗一下,基本上都用select实现非阻塞监听,但问题是,监听的是用select之后是不能像getchar()那样,即时收到单个字符的输入,必须要等待回车。

    经过努力不怠咁google... [好吧,还是google。没有google什么也做不了。]

    最后系一大堆英文资料入面,拼凑出如下可用的代码,实现了单个字符非阻塞输入。

    show code below.

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" python non blocking input
"""
__author__ = 'Zagfai'
__version__=  '2013-09-13'

import sys
import select
from time import sleep
import termios
import tty

old_settings = termios.tcgetattr(sys.stdin)
tty.setcbreak(sys.stdin.fileno())
while True:
    sleep(.001)
    if select.select([sys.stdin], [], [], 0) == ([sys.stdin], [], []):
        c = sys.stdin.read(1)
        if c == '\x1b': break
        sys.stdout.write(c)
        sys.stdout.flush()
termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)

print raw_input('123:')

    其中用到两个模块,分别系termios、tty,用来控制tty的输入模式,由行输入变为单字符。

    END.

2018-04-24 11:02:18 li_wen01 阅读数 5274

    非阻塞式I/O包括非阻塞输入操作,非阻塞输出操作,非阻塞接收外来连接,非阻塞发起外出连接。包括的函数有:read, readv, recv, recvfrom, recvmsg, write, writev, send, sendto, sendmsg, accept。

    将socket 设置为非阻塞模式有三总方法:

    (1)创建socket的时候,指定socket是异步的,在type的参数中设置SOCK_NONBLOCK标志即可。

int socket(int domain, int type, int protocol);
int s = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
    (2)使用fcntl函数:

fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK);
    (3)使用ioctl函数:

ioctl(sockfd, FIONBIO, 1);  //1:非阻塞 0:阻塞
下面改写linux网络编程:使用多进程实现socket同时收发数据 中的程序

/*=============================================================================
#     FileName: nonblocktcp.c
#         Desc: set the connetfd unblock
#       Author: licaibiao
#   LastChange: 2017-02-14 
=============================================================================*/
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include <fcntl.h>

#define MAXLINE 256
#define PORT	6666


void process_out(int signo)
{
	exit(EXIT_SUCCESS);
}


void write_func(int pid, int fd)
{
	char* write = "I am server";
	
	printf("write id = %d\n",pid);

	signal(SIGUSR1,process_out);  
	while(1)
	{
		sleep(1);
		send(fd,write,strlen(write)+1,0);
	}

}


void read_func(int pid, int fd)
{
	char readbuff[MAXLINE];
	int n = 0;

	printf("read id = %d \n",pid);

	memset(&readbuff,0,sizeof(readbuff));
	
	while(1)
	{
		n = recv(fd, readbuff, MAXLINE, 0); 
		if(n > 0) 			
		{
			printf("server recv data: %s \n",readbuff);
		}
		else if(n == 0)		
		{
			break;
		}
		sleep(1);
		//printf("===\n");
	};
	
	printf("exit read function\n");
	kill(pid, SIGUSR1); 
	exit(EXIT_SUCCESS);
}


int main(void)
{
	int listenfd,connetfd;
	int on = 1;
	int addrlen = 0;
	int flags;
	pid_t pid, pid_child, pid_send;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;


	if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
	{
		printf("create socket err \n");
	}
	
	addrlen = sizeof(struct sockaddr_in);
	memset(&server_addr, 0, addrlen);
	server_addr.sin_family = AF_INET;    
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY); 
	server_addr.sin_port = htons(PORT); 

	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)   
	{
		printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
		exit(0);
	}

	
	if( bind(listenfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1)
	{
		printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
		exit(0);
	}
	
	
	if( listen(listenfd, 10) == -1)
	{
		printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
		exit(0);
	}
	
	printf("wait client accpt \n");
	while(1)
	{
		
		if( (connetfd = accept(listenfd, (struct sockaddr*)&client_addr, &addrlen)) == -1)
		{
			printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
			continue;
		}

		/* set NONBLOCK */
		flags = fcntl(connetfd, F_GETFL, 0);
		fcntl(connetfd, F_SETFL, flags | O_NONBLOCK);

		signal(SIGCHLD, SIG_IGN);
		pid = fork();
		if(pid == -1)
		{
			printf("fork err \n");
		}
	
		if(pid == 0)					
		{
			pid_child = fork(); 
			if(pid_child == 0)  		
			{
				pid_send = getpid(); 	
				read_func(pid_send, connetfd);
			}
			else
			{
				pid_send = getpid(); 	
				write_func(pid_send,connetfd);
			}
		}

	}
}
   在该程序中,当接收到客户端的一个连接后,将连接描述符设置成非阻塞的:

		flags = fcntl(connetfd, F_GETFL, 0);
		fcntl(connetfd, F_SETFL, flags | O_NONBLOCK);

    这样设置之后,在读和写函数中的send和recv函数都变为了非阻塞模式。在这里我们使用的是sleep来做一个延时循环检测数据可读和数据可发送。在这里常用的套接字超时并不是sleep函数。我们可以使用下面的三种套接字超时方法。

套接字超时:

    (1)调用alarm,它在指定超时期满时产生SIGALARM信号,这与linux信号处理类似。

static void sig_alrm(int signo)
{
	return;			/* just interrupt the recvfrom() */
}

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int	n;
	char	sendline[MAXLINE], recvline[MAXLINE + 1];

	signal(SIGALRM, sig_alrm);

	while (Fgets(sendline, MAXLINE, fp) != NULL) {

		sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

		alarm(5);
		if ( (n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL)) < 0) {
			if (errno == EINTR)
				fprintf(stderr, "socket timeout\n");
			else
				err_sys("recvfrom error");
		} else {
			alarm(0);
			recvline[n] = 0;	/* null terminate */
			fputs(recvline, stdout);
		}
	}
}

    (2)在select 中阻塞等待I/O(select 有内置的时间限制),以此代替直接阻塞在read或write调用上。

int readable_select(int fd, int sec)
{
	fd_set			rset;
	struct timeval	tv;

	FD_ZERO(&rset);
	FD_SET(fd, &rset);

	tv.tv_sec = sec;
	tv.tv_usec = 0;

	return(select(fd+1, &rset, NULL, NULL, &tv));
		/* 4> 0 if descriptor is readable */
}

    (3)使用较新的SO_RCVTIMEO和SO_SNDTIMEO套接字选项。

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int				n;
	char			sendline[MAXLINE], recvline[MAXLINE + 1];
	struct timeval	tv;

	tv.tv_sec = 5;
	tv.tv_usec = 0;
	setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

	while (fgets(sendline, MAXLINE, fp) != NULL) {

		sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

		n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
		if (n < 0) {
			if (errno == EWOULDBLOCK) {
				fprintf(stderr, "socket timeout\n");
				continue;
			} else
				err_sys("recvfrom error");
		}

		recvline[n] = 0;	/* null terminate */
		fputs(recvline, stdout);
	}
}

2016-01-01 22:25:48 qq_14835443 阅读数 4817

linux常用输入函数scanf和getchar通常都是阻塞式的,如果用户没有输入,程序就一直停在那儿;输入内容后,还需要用户点回车;同时,用户输入的信息,会在屏幕上显示出来。
而某些时候,我们不期望这种阻塞发生,也不想要敲入的按键在屏幕上回显,我们希望这一切都由自己写的程序来控制,键盘被按下,我们能够立刻响应,而不需要额外输入回车。
代码如下:

#include<stdio.h>
#include <stdlib.h>

#define TTY_PATH            "/dev/tty"
#define STTY_US             "stty raw -echo -F "
#define STTY_DEF            "stty -raw echo -F "

static int get_char();

static int get_char()
{
    fd_set rfds;
    struct timeval tv;
    int ch = 0;

    FD_ZERO(&rfds);
    FD_SET(0, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 10; //设置等待超时时间

    //检测键盘是否有输入
    if (select(1, &rfds, NULL, NULL, &tv) > 0)
    {
        ch = getchar(); 
    }

    return ch;
}

int main()
{
    int ch = 0;
    system(STTY_US TTY_PATH);

    while(1)
    {
        ch = get_char();
        if (ch)
        {
            printf("key = %d(%c)\n\r", ch, ch);
            switch (ch)
            {
                case 3//ctrl+c
                    {system(STTY_DEF TTY_PATH);return 0;}
                case '0':
                    printf("0\n\r");break;
                case '1':
                    printf("1\n\r");break;
                case '2':
                    printf("2\n\r");break;
                case '3':
                    printf("3\n\r");break;
            }
        }           
    }
}

运行结果:
这里写图片描述

2019-04-22 18:03:02 weixin_38815609 阅读数 106

阻塞读终端:block指当串口输入缓冲区没有数据的时候,read函数将会阻塞在这里,移植到串口输入缓冲区中有数据可读取,read读到了需要的字节数之后,返回值为读到的字节数

#include <unistd.h>
#include <stdlib.h>

int main(void)
{
	char buf[10];
	int n;
	n = read(STDIN_FILENO, buf, 10);
	if (n < 0) 
  {
		perror("read STDIN_FILENO");
		exit(1);
	}
	write(STDOUT_FILENO, buf, n);
	return 0;
}

非阻塞读终端:no block指当串口输入缓冲区没有数据的时候,read函数立即返回,返回值为0

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#define MSG_TRY "try again\n"

int main(void)
{
	char buf[10];
	int fd, n;
	fd = open("/dev/tty", O_RDONLY|O_NONBLOCK);
	if(fd<0)
	{
		perror("open /dev/tty");
		exit(1);
	}

tryagain:
    n = read(fd, buf, 10);
	if (n < 0)
	{
		if (errno == EAGAIN)
		{
			sleep(1);
		//	write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));//
			goto tryagain;
		}
		perror("read /dev/tty");
		exit(1);
	}
	write(STDOUT_FILENO, buf, n);
	close(fd);
	return 0;
}

[Linux]非阻塞读

阅读数 873

没有更多推荐了,返回首页