七、文件IO——I/O处理方式和文件锁

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

7.1 I/O 处理方式

7.1.1 I/O处理的五种模型

阻塞I/O模型
- 若所调用的 I/O 函数没有完成相关的功能就会使进程挂起，直到相关数据到达才会返回。如终端、网络设备的访问。
非阻塞模型
- 当请求的 I/O 操作不能完成时，则不让进程休眠，而且返回一个错误。如 open read write 访问
I/O 多路转接模型
- 如果请求的 I/O 操作阻塞，且他不使真正阻塞 I/O，而且让其中一个函数等待，在这期间，I/O 还能进行其他操作。如 select 函数
信号驱动 I/O 模型
- 在这种模型下，通过安装一个信号处理程序，系统可以自动捕获特定信号的到来，从而启动 I/O
异步 I/O 模型
- 在这种模型下，当一个描述符已准备好，可以启动 I/O，进程会通知内核。由内核进行后续处理，这种用法现在较少

7.1.2 非阻塞I/O

低速系统调用时，进程可能会阻塞
非阻塞I/O确定操作（read, open, write）不阻塞，如果操作不能完成，则出错返回
设定非阻塞方式
- 使用 open 打开文件，设置 O_NONBLOCK 标志
- 如果一个文件已经打开，则使用 fcntl 修改文件状态标志为非阻塞

7.1.3 例子

nonblock_read.c

 /* 从标准输入读取信息，然后在屏幕上输出

  * 测试：

  *     （1）在睡眠 5s 内 按ctrl + d 屏幕会输出 read finished

  *             ctrl + d 是给程序发送读取结束的信号，即读到了文件末尾

  *     （2）运行程序后，等待5s 输出 read error，程序不会阻塞在那里，没有输入，size < 0

  *     （3）在5 s 内输入字符，会正常输出字符

  */

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <fcntl.h>

 #include <unistd.h>

 #include <string.h>

 #include <errno.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <fcntl.h>

 #include "io.h"

 int main(int argc, const char *argv[])

 {

     char buff[] = {'\0'};

     ssize_t size = ;

     //设置非阻塞 IO

     sleep();

     set_fl(STDIN_FILENO, O_NONBLOCK);

     /* read 函数未设置 O_NONBLOCK, 默认是阻塞状态的 */

     size = read(STDIN_FILENO, buff, sizeof(buff));

     if(size < ) {

         perror("read error");

         exit();

     } else if (size == ) {

         printf("read finished!!\n");

     } else {

         if(write(STDOUT_FILENO, buff, size) != size) {

             perror("write error");

         }

     }

     return ;

 }

7.2 文件锁

7.2.1 文件锁介绍

当多个用户共同使用、操作一个文件的时候，Linux 通常采用的方法是给文件上锁，来避免共享资源产生竞争的状态。
谁获得了锁，就可以对文件进行操作
文件锁按功能分为共享读锁和独占写锁：
- 共享读锁：
  - 文件描述符必须只读打开
  - 一个进程上了读锁，其他进程也可以上读锁进行读取
- 独占写锁：
  - 文件描述符必须只写打开
  - 一个进程上了写锁，其他进程就不能上写锁和读锁进行读写操作
文件锁按类型分为建议锁和强制性锁
- 建议性锁要求上锁文件的进程都要检测是否由锁存在，并尊重已由的锁
- 强制性锁由内核和系统执行的锁。文件挂载就是强制性锁
fcntl 不仅可以实施建议性锁，而且可以实施强制性锁

这里用到 fcntl 函数

 #include <unistd.h>

 #include <fcntl.h>

 int fcntl(int fd, int cmd, struct flock *lock);

cmd：F_SETLK F_GETLK F_SETLKW，前两种默认是非阻塞的，后面一种是阻塞时候用的

 struct flock {

     short l_type;                /* F_RDLCK, F_WRLCK， or F_UNLCK */

     short l_whence;                /* SEEK_SET, SEEK_CUR, SEEK_END */

     __kernel_off_t    l_start;

     __kernel_off_t    l_len;

     __kernel_pid_t    l_pid;

     __ARCH_FLOCK_PAD

 };

l_type：
- 锁类型，F_RDLCK(共享读锁)、F_WRLCK（独占性写锁）或F_UNLCK（解锁一个区域）
l_start、l_whence
- 要加锁或解锁的区域的起始地址，由 l_start 和 l_whence 两者决定
- l_start 是相对位移量，l_whence 则决定相对位移量的起点
l_len
- 表示区域的长度
加锁解锁区域的注意点：
- 该区域可以在当前文件尾端处开始或越过其尾端处开始，但是不能在文件起始位置之前开始或越过该起始位置
- 若 l_len 为0，则表示锁的区域从其起点（由 l_start 和 l_whence 决定）开始直至最大可能位置为止。也就是不管添写到文件中多少数据，它都处于锁的范围
- 为了锁整个文件，通常的方法是将 l_start 设置为0，l_whence 设置为 SEEK_SET，l_len 设置为0

锁的继承和释放：

一个进程终止，它所建立的锁全部释放

关闭一个文件描述符，此进程对该文件的所有的锁均释放

子进程不继承父进程的锁

执行 exec 以后，新程序可以选择是否继承原来执行进程的锁

7.2.2 例子

两个进程进行相互排斥写

io.c

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <fcntl.h>

 #include <unistd.h>

 #include "io.h"

 #include <string.h>

 #include <errno.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <fcntl.h>

 #define BUFFER_LEN 1024

 /* 文件的读写拷贝 */

 void copy(int fdin, int fdout)

 {

     char buff[BUFFER_LEN];

     ssize_t size;

 //    printf("file length: %ld\n", lseek(fdin, 0L, SEEK_END));//将文件定位到文件尾部，偏移量为0L

 //    lseek(fdin, 0L, SEEK_SET);// 定位到文件开头

     while((size = read(fdin, buff, BUFFER_LEN)) > ) { //从 fdin 中读取 BUFFER_LEN 个字节存放入  buff 中

 //        printf("current: %ld\n", lseek(fdin, 0L, SEEK_CUR));

         if(write(fdout, buff, size) != size) {

             fprintf(stderr, "write error: %s\n", strerror(errno));

             exit();

         }

     }

     if(size < ) {

         fprintf(stderr, "read error:%s\n", strerror(errno));

         exit(); // 相当于 return 1;

     }

 }

 void set_fl(int fd, int flag)

 {

     int val;

     //获得原来的文件状态标志

     val = fcntl(fd, F_GETFL);

     if(val < ) {

         perror("fcntl error");

     }

     //增加新的文件状态标志

     val |= flag;

     //重新设置文件状态标志(val 为新的文件状态标志)

     if(fcntl(fd, F_SETFL, val) < ) {

         perror("fcntl error");

     }

 }

 void clr_fl(int fd, int flag)

 {

     int val;

     val = fcntl(fd, F_GETFL);

     if(val < ) {

         perror("fcntl error");

     }

     //清除指定的文件状态标志（设置为0）

     val &= ~flag;

     if(fcntl(fd, F_SETFL, val) < ) {

         perror("fcntl error");

     }

 }

74 int lock_reg(int fd, int cmd, short type, off_t offset, short whence, off_t length)

75 {

76     struct flock flock;

77     flock.l_type = type;

78     flock.l_start = offset;

79     flock.l_whence = whence;

80     flock.l_len = length;

81     //flock.l_pid = getpid();

82     //l_pid：加锁、解锁进程的进程号(pid)

83

84     if(fcntl(fd, cmd, &flock) < 0) {

85         perror("fcntl error");

86         return 0;

87     }

88

89     return 1;

90 }

io.h

 #ifndef __IO_H__

 #define __IO_H__

 #include <sys/types.h>

 extern void copy(int fdin, int fdout);

 extern void set_fl(int fd, int flag);

 extern void clr_fl(int fd, int flag);

 extern int lock_reg(int fd, int cmd, short type, off_t offset, short whence, off_t length);

 /* 共享读锁，阻塞版本 */

14 #define REAK_LOCKW(fd, offset, whence, length) \

15     lock_reg(fd, F_SETLKW, F_RDLCK, offset, whence, length)

 

 /* 共享读锁，非阻塞版本 */

19 #define REAK_LOCK(fd, offset, whence, length) \

20     lock_reg(fd, F_SETLK, F_RDLCK, offset, whence, length)



 /* 独占写锁，阻塞版本 */

23 #define WRITE_LOCKW(fd, offset, whence, length) \

24     lock_reg(fd, F_SETLKW, F_WRLCK, offset, whence, length)



 /* 独占写锁，非阻塞版本 */

27 #define WRITE_LOC(fd, offset, whence, length) \

28     lock_reg(fd, F_SETLK, F_WRLCK, offset, whence, length)



 /* 解锁,非阻塞版本 */

31 #define UNLOCK(fd, offset, whence, length) \

32     lock_reg(fd, F_SETLK, F_UNLCK, offset, whence, length)



 #endif

lock_write.c

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <fcntl.h>

 #include <unistd.h>

 #include <string.h>

 #include <errno.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <fcntl.h>

 #include "io.h"

 int main(int argc, char *argv[])

 {

     if(argc < )

     {

         printf("Usage: %s content file lock | unlock\n", argv[]);

         exit();

     }

     ssize_t size = strlen(argv[]) * sizeof(char);

     int fd = open(argv[], O_WRONLY | O_CREAT, );

     if(fd < ) {

         perror("open error");

         exit();

     }

     sleep();

     printf("current pid pid: %d\n", getpid());

     //如果要加锁，则加的是独占写锁，阻塞版本

     //第二个进程想要对文件加文件锁（这里是独占写锁）

     //必须要等前一个进程释放文件锁后方可加锁

     if(!strcmp("lock", argv[])) {

         WRITE_LOCKW(fd, , SEEK_SET, );//整个文件上锁

         printf("lock success\n");

     }

     //写字符串

     char *p = argv[];

     int i;

     for(i = ; i < size; i++) {

         if(write(fd, (p + i), ) != ) {

             perror("write error");

             exit();

         }

         printf("%d success write one character\n", getpid());

         sleep();

     }

     //解锁

     if(!strcmp("lock", argv[])) {

         UNLOCK(fd, , SEEK_SET, );

         printf("unlock success\n");

         printf("unlock pid: %d", getpid());

     }

     close(fd);

     return ;

 }

编译，编写后台运行脚本

start.h

 ./bin/lock_write aaaaaa demo.txt lock &

 ./bin/lock_write AAAAAA demo.txt lock &

执行start.h 执行结果如下：

可以看见，一个进程对文件加锁之后，必须写完之后，并释放了锁之后，另一个进程才可以执行写操作。当一个进程执行完程序后，会自动释放锁，另一个进程再开始写，锁的释放完成是因为程序执行完或是关闭了文件。

对共享读锁来说，一个进程加了锁，另一个进程也可以加锁，没影响。

修改下 start.h 脚本，让第二个进程不加锁

 ./bin/lock_write aaaaaa demo.txt lock &

 ./bin/lock_write AAAAAA demo.txt unlock &

运行脚本后的运行结果如下：

可以看到两个进程再交替进行写。第二个进程没有加锁，写代码区依然可以运行。

这种锁就是建议性锁，要写文件可以建议加锁区写，但是没加锁也可以写，当前Linux默认是这样做的。

正文

7.1 I/O 处理方式

7.1.1 I/O处理的五种模型

7.1.2 非阻塞I/O

7.1.3 例子

7.2 文件锁

7.2.1 文件锁介绍

7.2.2 例子

相关阅读

冒号操作符javascript，冒号正确使用方式

js判断的方法有哪些方法有哪些，js判断类型的几种方式

设计股份模式，股份公司设计方式

设计的合作模式，设计合作方式

jquery属性扩展，jquery扩展插件的方式

反射与代理设计模式，反射的原理,反射创建类实例的三种方式是什么?

mongodb分页查询实现方式，mongodb分组查询

js创建对象this什么意思，js创建对象的两种方式

目录[+]