引言：高级I/O包括非阻塞I/O、记录锁、系统V流机制、I/O多路转接（select和poll函数）、readv和writev函数以及存储映射I/O。

（一）非阻塞I/O

可能会使进程永远阻塞的一类系统调用有：

1、如果某些文件类型的数据并不存在，则读操作可能会使调用者永远阻塞。

2、如果数据不能立即被上述同样类型的文件接受，则写操作也会使调用者永远阻塞。

3、在某种条件发生之前，打开某些类型的文件会阻塞。

4、对已经加上强制记录锁的文件进行读、写。

5、某些ioctl操作。

6、某些进程间通信函数。

对于一个给定的描述符有两种方法对其指定非阻塞I/O：

1、如果调用open获得描述符，则可指定O_NONBLOCK标志。

2、对于已经打开的一个描述符，则可调用fcntl，由该函数打开O_NONBLOCK文件状态标志。

/*
 *File Name : nonblock.c
 *Author    : libing
 *Mail      : libing1209@126.com
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

char buf[500000];

void 
set_fl(int fd, int flags) 	/*flags are file status falgs to turn on*/	
{
	int val;

	if((val = fcntl(fd, F_GETFL, 0)) < 0)
		printf("fcntl F_GETFL error");

	val |= flags;	/*打开flags标志*/ 

	if(fcntl(fd, F_SETFL, val) < 0)
		printf("fcntl F_SETFL error");
}

void 
clr_fl(int fd, int flags) 	/*flags are file status falgs to turn on*/	
{
	int val;

	if((val = fcntl(fd, F_GETFL, 0)) < 0)
		printf("fcntl F_GETFL error");

	val &= ~flags;	/*关闭flags标志*/ 

	if(fcntl(fd, F_SETFL, val) < 0)
		printf("fcntl F_SETFL error");
}

int
main(void)
{
	int errno;
	char *ptr;
	int ntowrite, nwrite;

	ntowrite = read(STDIN_FILENO, buf, sizeof(buf));
	fprintf(stderr, "read %d bytes\n", ntowrite);

	set_fl(STDOUT_FILENO, O_NONBLOCK); 	/*设置非阻塞标志O_NONBLOCK*/

	ptr = buf;
	while(ntowrite > 0){
		errno = 0;
		nwrite = write(STDOUT_FILENO, ptr, ntowrite);
		fprintf(stderr, "nwrite = %d, errno = %d\n", nwrite, errno);

		if(nwrite > 0){
			ptr += nwrite;
			ntowrite -= nwrite;	
		}	
	}
	clr_fl(STDOUT_FILENO, O_NONBLOCK);	/*设置非阻塞标志O_NONBLOCK*/
	exit(0);
}

记录锁的功能是：当一个进程正在读或修改文件的某个部分时，它可以阻止其他进程修改同一文件区。

#include <fcntl.h>

int fcntl(int fd, int cmd, .../*struct flock *flockptr*/)；//返回值：若成功则依赖cmd，若出错则返回-1。

flockptr是一个指向flock结构的指针（bits/fcntl.h文件中）。

struct flock
  {
    short int l_type;	/* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK.	*/
    short int l_whence;	/* Where `l_start‘ is relative to (like `lseek‘).  */
#ifndef __USE_FILE_OFFSET64
    __off_t l_start;	/* Offset where the lock begins.  */
    __off_t l_len;	/* Size of the locked area; zero means until EOF.  */
#else
    __off64_t l_start;	/* Offset where the lock begins.  */
    __off64_t l_len;	/* Size of the locked area; zero means until EOF.  */
#endif
    __pid_t l_pid;	/* Process holding the lock.  */
  };

1、所希望的锁类型：F_RDLCK（共享读锁）、F_WRLCK（独占性写锁）、F_UNLCK（解锁一个区域）。

2、要加锁或解锁区域的起始字节偏移量，这由l_start和l_whence两者决定。

3、区域的字节长度，由l_len表示。

4、具有能阻塞当前进程的锁，其持有进程的ID存放在l_pid中。

关于加锁和解锁的区域的说明还要注意：

1、l_start是相对偏移量（字节），l_whence则决定了相对偏移量的起点。这与lseek函数中最后两个参数类似。确实，l_whence可选用的值是SEEK_SET、SEEK_CUR和SEEK_END。

2、该区域可以在当前文件尾端处开始或越过其尾端处开始，但不能再文件起始位置之前开始。

3、如若l_len为0，则表示锁的区域从其起点(由l_start和l_whence决定)开始直至最大可能偏移量为止，也就是不管添写到该文件中多少数据，它们都处于锁的范围内。

4、为了锁整个文件，设置l_start和l_whence，使锁的起点在文件起始处，并且说明长度(l_len)为0。

所得类型有两种：共享读锁(l_type为F_RDLCK)和独占写锁(F_WRLCK)。基本规则：多个进程在一个给定的字节上可以有一把共享读锁，但是在一个给定字节上只能有一个进程独用的一把写锁。如果在一个给定字节上已经有一把或多把读锁，则不能再该字节上再加写锁；如果在一个字节上已经有了一把独占性的写锁，则不能再对它加任何读锁。

上面所说的规则适用于不同进程提出的锁请求，并不适用于单个进程提出的多个锁请求。如果一个进程对一个文件区间已经有了一把锁，后来该进程又企图在同以文件区间再加一把锁，那么新锁将替换老锁。

加读锁时，该描述符必须是读打开的；加写锁时，该描述符必须是写打开的。

根据cmd的不同，fcntl函数的三种命令如下：

1、F_SETLK 设置由flockptr所描述的锁。如果试图建立一把读锁(l_type设为F_RDLCK)或写锁（l_type设为F_WRLCK），如果失败，则fcntl立即出错返回，此时errno设置为EACCESS 或EAGAIN。此命令也用来清除由flockptr说明的锁(l_type为F_UNLCK)。

示例代码：

#define read_lock(fd, offset, whecne, len) 		lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
#define write_lock(fd, offset, whecne, len) 		lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
#define un_lock(fd, offset, whecne, len) 		lock_reg((fd), F_SETLK, F_UNLCK, (offset), (whence), (len))
int 
lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
	struct flock lock;

	lock.l_type = type;  /*F_RDLCK, F_WRLCK, F_UNLCK*/
	lock.l_start = offset; /*byte offset, relative to l_whence*/
	lock.l_whence = whence; /*SEEK_SET, SEEK_CUR, SEEK_END*/
	lock.l_len = len;

	return(fcntl(fd, cmd, &lock)); 
}

3、F_GETLK 判断由flockptr所描述的锁是否会被另外一把锁所排斥（阻塞）。如果存在一把锁，它阻止创建由flockptr所描述的锁，则把该现存锁的信息写到flockptr指向的结构中。如果不存在这种情况，则除了将l_type设置为F_UNLCK之外，flockptr所指向结构中的其他信息保持不变。

#define is_read_lockable(fd, offset, whecne, len) 		lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
#define is_write_lockable(fd, offset, whecne, len) 		lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
int 
lock_test(int fd, int type, off_t offset, int whence, off_t len)
{
	struct flock lock;

	lock.l_type = type;  /*F_RDLCK, F_WRLCK*/
	lock.l_start = offset; /*byte offset, relative to l_whence*/
	lock.l_whence = whence; /*SEEK_SET, SEEK_CUR, SEEK_END*/
	lock.l_len = len;

	if(fcntl(fd, F_GETLK, &lock) < 0)
		printf("fcntl error");

	if(lock.l_type == F_UNLCK)
		return 0;        /*false , region isn‘t locked by another proc*/
	return(lock.l_pid); /*true , return pid of lock  owner*/
}

死锁：如果两个进程相互等待对方持有并且锁定的资源时，则这两个进程就处于死锁状态。
apue上的死锁实例：

#include <fcntl.h>

static void
lockabyte(const char *name, int fd, off_t offset)
{
	if(write_lock(fd, offset, SEEK_SET, 1) < 0)
		err_sys("%s:writew_lock error", name);
	printf("%s:got the lock,byte %ld\n",name , offset);
}

int
main(void)
{
	int fd;
	pid_t pid;

	/*
	 *Create a file and write two bytes to it.
	 */
	if((fd = creat("templock", FILE_MODE)) < 0)
		err_sys("creat errror");
	if(write(fd, "ab", 2) != 2)
		err_sys("write error");

	TELL_WAIT();
	if((pid = fork()) < 0){
		err_sys("fork error");	
	}else if(pid == 0){
		lockabyte("child", fd, 0);	
		TELL_PARENT(getppid());
		WAIT_PARENT();
		lockabyte("child", fd, 1);
	}else{
		lockabyte("parent", fd, 1);	
		TELL_PARENT(pid);
		WAIT_PARENT();
		lockabyte("parent", fd, 0);
	}
	exit(0);
}

1、锁与进程和文件有关。当一个进程终止时，它所建立的锁全部释放；任何时候关闭一个描述符时，则该进程通过这一描述符可以引用的文件上的任何一把锁都被释放。

2、由fork产生的子进程不继承父进程所设置的锁。

3、在执行exec后，新程序可以继承原执行程序的锁。但如果对一个文件描述符设置了clos_on_exec标志，那么当作为exec的一部分关闭该文件描述符时，对相应文件的所有锁都被释放。