阻塞IO：

一直阻塞程序直到完成IO操作。

非阻塞IO：

有資料時進行IO操作，沒有資料時立即返回不阻塞程序。

訊號驅動IO：

當有資料到來是傳送訊號給程序執行IO操作，提高CPU的利用率。當設定開啟檔案描述字O_ASYNC標誌是可以用於訊號驅動的IO操作，也可以用過fcntl()改變檔案標籤，當檔案進行IO操作時會產生SIGIO訊號或套接字有帶外資料到來時會產生SIGURG訊號。通過fcntl函式執行F_SETOWN命令可以設定/獲得，接收訊號的程序/程序組ID。

具體例項：

/*
 * main.c
 *
 *  Created on: 2016年10月22日
 *      Author: chy
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <termios.h>
#include <signal.h>
#include <sys/fcntl.h>
#include <sys/fcntl.h>
#include <stdio.h>
#include <stdlib.h>

FILE *file;

void sigfunc(int sig)
{
	char c,input[128];
	int n;
	static int i = 0;

	if(read(STDIN_FILENO,&c,1) > 0){
		if(c != '\n')
			input[i++] = c;
		else {
			input[i++] = '\0';
			fprintf(file,"NO sig=%d, input line is %s\n",i,input);
			i = 0;
			 if(c == 'q'){
				 fclose(file);
				 _exit(0);
			 }
		}
	}
}

int main(int argc,char *argv)
{
	int falg;
	char buff[256];
	struct termios newseting,old_termios;
	file = fopen("test.txt","w");
	signal(SIGIO,sigfunc);

	tcgetattr(STDIN_FILENO,&old_termios);
	newseting = old_termios;
	newseting.c_iflag &= (~ICANON);
	newseting.c_cc[VTIME] = 0;
	newseting.c_cc[VMIN] = 1;
	tcsetattr(STDIN_FILENO, TCSANOW, &newseting);
	fcntl(STDIN_FILENO, F_SETOWN,getpid());
	falg = fcntl(STDIN_FILENO, F_GETFL,0);
	falg |= O_ASYNC;
	fcntl(STDIN_FILENO,F_SETFL,falg);
	while(1) sleep(1);

	return 0;
}
 

多路轉接IO：

處理來自多個通道的輸入，通過select函式告訴呼叫它的程序需要等待IO事件的數量。

#include <sys/select.h>
#include <sys/time.h>
int select(int nfds,fd_set *rfds,fd_set *wfds,fd_set *edfs,struct timeval *timeout);
void FD_ZERO(fd_set *fdset); //初始化描述字為空
void FD_CLR(int filedes,fd_set *fdset); //將filedes描述字從fdset描述字集合中清除
int FD_ISSET(int fileds,fd_set *fdset); //判斷filedes是否屬於fdset所指的描述
void FD_SET(int filedes,fd_set *fdset);  //將filedes新增到描述字fset所指的集合中
select中的三個測試描述字集合都為空可以做為定時器切精度高於sleep。
 

#include <aio.h>
int aio_write(struct aiocb *aiocbp);//返回實際寫入的位元組數
int aio_read(struct aiocb *aiocbp); //返回實際讀出的位元組數
int lio_listio(int mode,struct aiocb *restrict const list[restrict],int nent,struct sigevent *restrict notification);
int aio_error(struct aiocb *aiocbp); //正在進行IO操作返回EINPROGRESS
ssize_t aio_return(struct aiocb *aiocbp); //返回讀寫位元組個數
int aio_suspend(const struct aiocb *const list[],int nent,const struct timespec *timeout); //掛起呼叫程序直到IO完成或時間到期
int aio_sysnc(int op,struct aiocb *aiocbp); //把資料同步到物理磁碟

struct aiocb{
     int aio_filds;
     off_t aio_offset;
     volatile void *aio_buf;
     size_t aio_nbytes;
     int aio_reqprio;
     struct sigevent aio_sigevent;
     int aio_lio_opcode;
};

struct sigevent{
     union sigval sigev_value;
     int sigv_signo;
     int sigev_notify;//非同步事件的通知型別 SIGEV_NONE（不通知）、SIGEV_SIGNAL(生成訊號)、SIGEV_THREAD(執行sigev_notify_function指定的函式)
     void (*sigev_notify_function) (union sigval);
     pthread_attr_t *sigev_notify_attrbutes;
};
 

/*
 * main.c
 *
 *  Created on: 2016年10月20日
 *      Author: chy
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <sys/unistd.h>
#include <aio.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#define buffer_num  2
#define buffer_size 2048
#define ERR(msg,f_num) { \
	if(f_num < 0) { \
		fprintf(stderr,"%s",msg); \
		exit(-1); \
	} \
}

typedef enum{
	buffer_ferr = 1,
	buffer_full,
	buffer_write
}BUFFER;

typedef struct {　//緩衝區結構
	BUFFER state;
	int fillpt;
	char buffer[buffer_size];
	struct aiocb aio;
}buffer_t;

static buffer_t buffer[buffer_num];
static sigset_t procmask;
static  int write_num = 0;
static int sig_num;
static volatile off_t seek_ptr;

void sig_func(int signo,siginfo_t *info,void *sig)
{
	int i;
	buffer_t  *temp;

	if(info->si_signo != SIGRTMIN || info->si_code != SI_ASYNCIO)
		return;
	else
		printf("write over\n");
	temp = (buffer_t*)info->si_value.sival_ptr;

	int write_temp_num = 0;
	if(aio_error(&temp->aio) != EINPROGRESS)
		write_temp_num = aio_return(&temp->aio);
	write_num += write_temp_num;
	sig_num++;

	temp->fillpt = 0;
	temp->state = buffer_ferr;
	return;
}

buffer_t *find_empty_buffer()
{
	int i;
	sigset_t newsig;
	sigprocmask(SIG_BLOCK,&procmask,&newsig);　//遮蔽非同步寫訊號量

	while(1){
		for(i = 0; i < buffer_num; i++)
			if(buffer[i].state == buffer_ferr)
				break;
		if(i == buffer_num)
			sigsuspend(&procmask);　//掛起SIGRTMIN
		else break;
	}
	buffer[i].state = buffer_full;
	buffer[i].fillpt = 0;
	sigprocmask(SIG_SETMASK,&procmask,NULL); //恢復遮蔽非同步寫訊號量
	return (&buffer[i]);
}

void buffer_flush(buffer_t *temp)
{
	temp->aio.aio_offset = seek_ptr; //檔案指標的位置
	seek_ptr += temp->fillpt;
	temp->aio.aio_buf = temp->buffer; //緩衝地地址
	temp->aio.aio_nbytes = temp->fillpt; //要傳輸的位元組數
	temp->aio.aio_reqprio = 0;   //優先移位0
	temp->aio.aio_sigevent.sigev_notify = SIGEV_SIGNAL; //實時訊號型別
	temp->aio.aio_sigevent.sigev_signo = SIGRTMIN; //訊號數
	temp->aio.aio_sigevent.sigev_value.sival_ptr = temp; //攜帶的資訊
	temp->state = buffer_write; //標記為正在寫的狀態

	ERR("write fail\n",aio_write(&temp->aio));

	return;
}

int main(int argc,char *argv[])
{
	int i,file_in,file_out;
	struct sigaction sig;
	buffer_t *buffer_opt;

	if(argc < 3){
		printf("please input three func\n");
		exit(0);
	}

	file_in = open(argv[1],O_RDONLY);
	ERR("open file_in faile\n",file_in);
	file_out = open(argv[2],O_WRONLY | O_CREAT,0777);
	ERR("open file_out faile\n",file_out);

	for(i = 0; i < buffer_num; i++){
		buffer[i].state = buffer_ferr;
		buffer[i].fillpt = 0;
		buffer[i].aio.aio_fildes = file_out; //繫結檔案描述字
	}

	buffer_opt = find_empty_buffer();
	sigemptyset(&procmask);
	sigaddset(&procmask,SIGRTMIN);
	sigemptyset(&sig.sa_mask);
	sig.sa_flags = SA_SIGINFO;
	sig.sa_sigaction = sig_func;

	ERR("sigaction fail\n",sigaction(SIGRTMIN,&sig,NULL));

	int read_num;
	while(1){
		while((read_num = read(file_in,buffer_opt->buffer + buffer_opt->fillpt,buffer_size)) != 0){
			if(read_num > 0){
				buffer_opt->fillpt += read_num;
				if(buffer_opt->fillpt == buffer_size){
					buffer_flush(buffer_opt);
					buffer_opt = find_empty_buffer();
					break;
				}
			}
			if(errno == EINTR)
				break;
			else if(read_num < 0 && errno != EINTR)
				ERR("read faile\n",-1);
		}
	   if(read_num == 0){
			printf("chen\n");
			buffer_flush(buffer_opt);
			break;
		}
	}
	 for(i = 0; i < buffer_num; i++)
		 if(buffer[i].state == buffer_write){
			 struct aiocb *temp[1];
			 temp[0] = &buffer[i].aio;
		     aio_suspend(temp, 1, NULL);
		 }
	 close(file_out);
	 close(file_in);
	 printf("this is over\n");

	 return 1;
}

儲存對映IO：傳統IO進行讀寫檔案要進行多次系統呼叫，並且把檔案載入到自己的地址空間，其效率低，浪費儲存空間。儲存對映IO，系統把檔案的一頁讀取到記憶體，每一個程序把改頁對映到自己的記憶體空間。對映後不再需要read等系統呼叫，可以通過指令直接訪問。儲存對映分為共享對映和私有對映，共享對映每個程序都能夠改變對映頁的內容，當一頁被重新整理時保回會物理磁碟。私有對映，寫檔案將導致複製該頁的一個副本，物理磁碟物件本身不改變。

#include <sys/mman.h>
void *mmap(void *addr,size_t len,int port,int flags,int filedes,off_t off);
int munmap(void *paddr,size_t len); //刪除對映
int msync(void *addr,size_t len,int flags); //寫入到物理磁碟
addr:對映區在記憶體的起始地址。
len：對映的位元組數。
prot：對映區的保護許可權。
flags：對映區的屬性。
filedes: 已開啟檔案的描述字。
off：檔案要對映的其實位元組位置。