文件高级---IO处理,文件锁,存储映射

最新推荐文章于 2023-06-08 21:52:17 发布
最新推荐文章于 2023-06-08 21:52:17 发布
阅读量840 收藏 1
点赞数
分类专栏： linux c 文章标签： 文件锁 存储映射 io处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25773973/article/details/50728406
版权

socket阻塞与非阻塞，同步与异步

1. 同步，就是我调用一个功能，该功能没有结束前，我死等结果。
2. 异步，就是我调用一个功能，不需要知道该功能结果，该功能有结果后通知我（回调通知）
3. 阻塞，      就是调用我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。
4. 非阻塞，  就是调用我（函数），我（函数）立即返回，通过select通知调用者

同步IO和异步IO的区别就在于：数据拷贝的时候进程是否阻塞！

阻塞IO和非阻塞IO的区别就在于：应用程序的调用是否立即返回！

对于举个简单c/s 模式：

同步：提交请求->等待服务器处理->处理完毕返回这个期间客户端浏览器不能干任何事
异步：请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

小结：同步就是当一个进程发起一个函数（任务）调用的时候，一直等待直到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。

阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程，即阻塞与非阻塞针对的是进程或线程而同步与异步所针对的是功能函数。

IO处理模型

1)阻塞I/O（blocking I/O）

在这个模型中，应用程序（application）为了执行这个read操作，会调用相应的一个system call，将系统控制权交给kernel，然后就进行等待（这其实就是被阻塞了）。kernel开始执行这个system call，执行完毕后会向应用程序返回响应，应用程序得到响应后，就不再阻塞，并进行后面的工作。
2)非阻塞I/O （nonblocking I/O）

在linux下，应用程序可以通过设置文件描述符的属性O_NONBLOCK，I/O操作可以立即返回，但是并不保证I/O操作成功。也就是说，当应用程序设置了O_NONBLOCK之后，执行write操作，调用相应的system call，这个system call会从内核中立即返回。但是在这个返回的时间点，数据可能还没有被真正的写入到指定的地方。也就是说，kernel只是很快的返回了这个 system call（只有立马返回，应用程序才不会被这个IO操作blocking），但是这个system call具体要执行的事情（写数据）可能并没有完成。而对于应用程序，虽然这个IO操作很快就返回了，但是它并不知道这个IO操作是否真的成功了，为了知道IO操作是否成功，一般有两种策略：一是需要应用程序主动地循环地去问kernel(这种方法就是同步非阻塞IO)；二是采用I/O通知机制，比如：IO多路复用(这种方法属于异步阻塞IO)或信号驱动IO(这种方法属于异步非阻塞IO)。
3) I/O复用(select 和poll) （I/O multiplexing）

和之前一样，应用程序要执行read操作，因此调用一个system call，这个system call被传递给了kernel。但在应用程序这边，它调用system call之后，并不等待kernel的返回结果而是立即返回，虽然立即返回的调用函数是一个异步的方式，但应用程序会被像select()、poll和epoll等具有复用多个文件描述符的函数阻塞住，一直等到这个system call有结果返回了，再通知应用程序。也就是说，“在这种模型中，IO函数是非阻塞的，使用阻塞 select、poll、epoll系统调用来确定一个 或多个I/O 描述符何时能操作。”所以，从IO操作的实际效果来看，异步阻塞IO和第一种同步阻塞IO是一样的，应用程序都是一直等到IO操作成功之后（数据已经被写入或者读取），才开始进行下面的工作。不同点在于异步阻塞IO用一个select函数可以为多个描述符提供通知，提高了并发性。举个例子：假如有一万个并发的read请求，但是网络上仍然没有数据，此时这一万个read会同时各自阻塞，现在用select、poll、epoll这样的函数来专门负责阻塞同时监听这一万个请求的状态，一旦有数据到达了就负责通知，这样就将之前一万个的各自为战的等待与阻塞转为一个专门的函数来负责与管理。与此同时，异步阻塞IO和第二种同步非阻塞IO的区别在于：同步非阻塞IO是需要应用程序主动地循环去询问是否有操作数据可操作，而异步阻塞IO是通过像select和poll等这样的IO多路复用函数来同时检测多个事件句柄来告知应用程序是否可以有数据操作。
4)信号驱动I/O （signal driven I/O (SIGIO)）

应用程序提交read请求的system call，然后，kernel开始处理相应的IO操作，而同时，应用程序并不等kernel返回响应，就会开始执行其他的处理操作（应用程序没有被IO操作所阻塞）。当kernel执行完毕，返回read的响应，就会产生一个信号或执行一个基于线程的回调函数来完成这次 I/O 处理过程。

从理论上说，阻塞IO、IO复用和信号驱动的IO都是同步IO模型。因为在这三种模型中，IO的读写操作都是在IO事件发生之后由应用程序来完成。而POSIX规范所定义的异步IO模型则不同。对异步IO而言，用户可以直接对IO执行读写操作，这些操作告诉内核用户读写缓冲区的位置，以及IO操作完成后内核通知应用程序的方式。异步IO读写操作总是立即返回，而不论IO是否阻塞的，因为真主的读写操作已经由内核接管。也就是说，同步IO模型要求用户代码自行执行IO操作(将数据从内核缓冲区读入用户缓冲区，或将数据从用户缓冲区写入内核缓冲区)，而异步IO机制则是由内核来执行IO操作(数据在内核缓冲区和用户缓冲区之间的移动是由内核在后台完成的)。你可以这样认为，同步IO向应用程序通知的是IO就绪事件，而异步IO向应用程序通知的是IO完成事件。linux环境下，aio.h头文件中定义的函数提供了对异步IO的支持。

5)异步I/O （asynchronous I/O (the POSIX aio_functions)）   

     异步IO与上面的异步概念是一样的， 当一个异步过程调用发出后，调用者不能立刻得到结果，实际处理这个调用的函数在完成后，通过状态、通知和回调来通知调用者的输入输出操作。异步IO的工作机制是：告知内核启动某个操作，并让内核在整个操作完成后通知我们，这种模型与信号驱动的IO区别在于，信号驱动IO是由内核通知我们何时可以启动一个IO操作，这个IO操作由用户自定义的信号函数来实现，而异步IO模型是由内核告知我们IO操作何时完成。为了实现异步IO，专门定义了一套以aio开头的API，如：aio_read.

 19 #include <stdio.h>
 20 #include <unistd.h>
 21 #include <fcntl.h>
 22 #include <string.h>
 23 #include <errno.h>
 24 #include <sys/types.h>
 25 #include <sys/time.h>
 26 #include <stdlib.h>
 27 
 28 int main(void)
 29 {
 30     fd_set set;
 31     FD_ZERO(&set);
 32     FD_SET(STDIN_FILENO, &set);
 33 
 34     struct timeval t;
 35     t.tv_sec = 2;
 36     t.tv_usec = 0;
 37 
 38     int n;
 39     while((n=select(STDIN_FILENO+1, &set,                                                                                                                 
 40                         NULL,NULL,&t)) != -1)
 41     {
 42         if(n == 0){
 43             printf("time out!n");
 44         }
 45         if(FD_ISSET(STDIN_FILENO, &set)){
 46             char buffer[100] = {};
 47             size_t num;
 48             num = read(STDIN_FILENO, buffer, 100);
 49             if(write(STDOUT_FILENO, buffer, num)
 50                         != num)
 51             {
 52                 fprintf(stderr, "write:%sn",
 53                             strerror(errno));
 54                 exit(1);
 55             }
 56         }
 57         t.tv_sec = 2;
 58         t.tv_usec = 0;
 59         FD_ZERO(&set);
 60         FD_SET(STDIN_FILENO, &set);
 61     }
 62     FD_CLR(STDIN_FILENO,&set);
 63     return 0;
 64 }
~


小结：前四种模型--阻塞IO、非阻塞IO、多路复用IO和信号驱动IO都属于同步模式，因为其中真正的IO操作(函数)都将会阻塞进程，只有异步IO模型真正实现了IO操作的异步性。

参考文章:http://blog.csdn.net/jay900323/article/details/18141217

http://www.ibm.com/developerworks/cn/linux/l-async/


文件锁机制

Linux下文件锁操作主要是通过以下两个API接口来完成的。

[cpp]  view plain  copy
 print ?
  1. #include <sys/file.h>  
  2. int flock(int fd, int operation);    

或者

[cpp]  view plain  copy
 print ?
  1. #include <unistd.h>  
  2. #include <fcntl.h>  
  3. int fcntl(int fd, int cmd);  
  4. int fcntl(int fd, int cmd, long arg);  
  5. int fcntl(int fd, int cmd, struct flock *lock);  
注：前者主要用于对整个文件的锁操作，后者可以对文件的部分内容进行锁操作。


Linux应用程序编程时应该注意以下几点：

1）文件锁是针对整个文件还是文件的部分内容。

2）进程级文件句柄关闭将会导致文件锁释放。

3）文件内容修改需要注意到glibc的缓冲机制，及时同步数据。

4）flock锁inode，fcntl锁文件描述符，因此flock不支持NFS，兼容性需要注意。

这里将给出进程级和线程级文件锁demo code供参考。

进程级文件锁demo：

[cpp]  view plain  copy
 print ?
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <errno.h>  
  4. #include <fcntl.h>  
  5. #include <unistd.h>  
  6.   
  7. #define TEST_FOPEN  
  8.   
  9. int main(int argc, char *argv[])  
  10. {  
  11.     /* l_type   l_whence  l_start  l_len  l_pid   */  
  12.     struct flock fl = {F_WRLCK, SEEK_SET,   0,      0,     0 };  
  13.     int fd;  
  14.   
  15. #ifdef TEST_FOPEN  
  16.     FILE *file = NULL;  
  17. #endif /* TEST_FOPEN */  
  18.   
  19.     fl.l_pid = getpid();  
  20.   
  21.     if (argc > 1)  
  22.         fl.l_type = F_RDLCK;  
  23.   
  24.     while(1)  
  25.     {  
  26. #ifdef TEST_FOPEN  
  27.     if ((file = fopen("lockdemo.c", "rw+")) == NULL) {  
  28.         perror("fopen");  
  29.         exit(1);  
  30.     }  
  31. #else  
  32.     if ((fd = open("lockdemo.c", O_RDWR)) == -1) {  
  33.         perror("open");  
  34.         exit(1);  
  35.     }  
  36. #endif /* TEST_FOPEN */  
  37.         printf("Press <RETURN> to try to get lock: ");  
  38.         getchar();  
  39.         printf("Trying to get lock...");  
  40.   
  41.     #ifdef TEST_FOPEN  
  42.         fd = fileno(file);  
  43.     #endif /* TEST_FOPEN */  
  44.   
  45.         fl.l_type = F_WRLCK;  /* set to lock same region */  
  46.         if (fcntl(fd, F_SETLKW, &fl) == -1) {  
  47.             perror("fcntl");  
  48.             exit(1);  
  49.         }  
  50.   
  51.         printf("got lock\n");  
  52.         printf("Press <RETURN> to release lock: ");  
  53.         getchar();  
  54.   
  55.         fl.l_type = F_UNLCK;  /* set to unlock same region */  
  56.   
  57.         if (fcntl(fd, F_SETLK, &fl) == -1) {  
  58.             perror("fcntl");  
  59.             exit(1);  
  60.         }  
  61.   
  62.         printf("Unlocked.\n");  
  63. #ifdef TEST_FOPEN  
  64.     fclose(file);  
  65. #else  
  66.     close(fd);  
  67. #endif /* TEST_FOPEN */  
  68.     }  
  69.   
  70.     return 0;  
  71. }  
运行结果：



线程级文件锁demo：

[cpp]  view plain  copy
 print ?
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <errno.h>  
  4. #include <fcntl.h>  
  5. #include <unistd.h>  
  6. #include <pthread.h>  
  7.   
  8. #define TEST_FOPEN  
  9. #define TEST_FLOCK  
  10.   
  11. void* thread_flock(void* ptr)  
  12. {  
  13.     /* l_type   l_whence  l_start  l_len  l_pid   */  
  14.     struct flock fl = {F_WRLCK, SEEK_SET,   0,      0,     0 };  
  15.     int fd;  
  16.   
  17.     int ith = *((int *)ptr);  
  18.   
  19. #ifdef TEST_FOPEN  
  20.     FILE *file = NULL;  
  21. #endif /* TEST_FOPEN */  
  22.   
  23.     fl.l_pid = getpid();  
  24.   
  25.     while(1)  
  26.     {  
  27. #ifdef TEST_FOPEN  
  28.     if ((file = fopen("lockdemo.c", "rw+")) == NULL) {  
  29.         perror("fopen");  
  30.         exit(1);  
  31.     }  
  32. #else  
  33.     if ((fd = open("lockdemo.c", O_RDWR)) == -1) {  
  34.         perror("open");  
  35.         exit(1);  
  36.     }  
  37. #endif /* TEST_FOPEN */  
  38.   
  39. #ifdef TEST_FOPEN  
  40.         fd = fileno(file);  
  41. #endif /* TEST_FOPEN */  
  42.   
  43. #ifdef TEST_FLOCK  
  44.         flock(fd, LOCK_EX);  
  45. #else  
  46.         fl.l_type = F_WRLCK;  /* set to lock same region */  
  47.         if (fcntl(fd, F_SETLKW, &fl) == -1) {  
  48.             perror("fcntl");  
  49.             exit(1);  
  50.         }  
  51. #endif /* TEST_FLOCK */  
  52.   
  53.         printf("[%d] %d --> got lock\n", ith, fd);  
  54.         sleep(ith);  
  55.   
  56. #ifdef TEST_FLOCK  
  57.         flock(fd, LOCK_UN);  
  58. #else  
  59.         fl.l_type = F_UNLCK;  /* set to unlock same region */  
  60.   
  61.         if (fcntl(fd, F_SETLKW, &fl) == -1) {  
  62.             perror("fcntl");  
  63.             exit(1);  
  64.         }  
  65. #endif /* TEST_FLOCK */  
  66.   
  67.         printf("[%d] %d--> Unlocked.\n", ith, fd);  
  68. #ifdef TEST_FOPEN  
  69.     fclose(file);  
  70. #else  
  71.     close(fd);  
  72. #endif /* TEST_FOPEN */  
  73.   
  74.         sleep(2);  
  75.     }  
  76. }  
  77.   
  78. int main(int argc, char *argv[])  
  79. {  
  80.     int time1, time2;  
  81.   
  82.     pthread_t pid1,pid2;  
  83.   
  84.     time1 = 1;  
  85.     pthread_create(&pid1, NULL, &thread_flock, &time1);  
  86.   
  87.     time2 = 3;  
  88.     pthread_create(&pid2, NULL, &thread_flock, &time2);  
  89.   
  90.     while(1)  
  91.         sleep(10);  
  92.   
  93.     return 0;  
  94. }  
运行结果：



参考文章:http://www.ibm.com/developerworks/cn/linux/l-cn-filelock/index.html

http://www.jb51.net/article/58757.htm

http://blog.csdn.net/lida2003/article/details/7267226

http://www.linuxidc.com/Linux/2013-09/90155.htm

存储映射

用存储映射的方式代替read和write更快.因为少了内核与用户空间的来回拷贝所以通常更快

建立内存映射mmap()和解除内存映射munmap()

头文件：#include <unistd.h>    #include <sys/mman.h>
定义函数：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offsize);
函数说明：mmap()用来将某个文件内容映射到内存中，对该内存区域的存取即是直接对该文件内容的读写。

头文件：#include <unistd.h>       #include <sys/mman.h>
定义函数：int munmap(void *start, size_t length);
函数说明：munmap()用来取消参数start 所指的映射内存起始地址，参数length 则是欲取消的内存大小。当进程结束或利用exec 相关函数来执行其他程序时，映射内存会自动解除，但关闭对应的文件描述词时不会解除映射。
返回值：如果解除映射成功则返回0，否则返回－1。错误原因存于errno 中错误代码EINVAL参数 start 或length 不合法。


#include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/mman.h>                                                       
 void main(){
     int fd;
     char *start;
     struct stat sb;
     fd = open("/etc/passwd", O_RDONLY); /*打开/etc/passwd */
     fstat(fd, &sb); /* 取得文件大小 */
     start = mmap(NULL, sb.st_size, PROT_READ, M_PRIVATE, fd, 0);
     if(start == MAP_FAILED) /* 判断是否映射成功 */
      return;
     printf("%s", start);
     munmap(start, sb.st_size); /* 解除映射 */
     close(fd);
 }
参考文章:https://www.ibm.com/developerworks/cn/linux/l-cn-zerocopy2/

http://www.ibm.com/developerworks/cn/linux/l-ipc/part5/index2.html

http://www.ibm.com/developerworks/cn/aix/library/au-highperform2/

https://www.ibm.com/search/csass/search/?q=%E5%AD%98%E5%82%A8%E6%98%A0%E5%B0%84mmap&dws=cndw&ibm-search.x=0&ibm-search.y=0&ibm-search=Search&sn=dw&lang=zh&cc=CN&ddr=&en=utf&lo=zh&hpp=20

那棵树好像真的生气了
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Linux系统编程、网络编程》 第9章 高级IO
06-12
课程内容：1.非阻塞IO 如何将阻塞的读写设置为非阻塞的读写。2.文件锁 1）使用fcntl函数实现 2）使用flock函数实现3.多路IO select方式，poll方式。 4.异步IO5.存储映射
Linux-基础IO
AI_ELF的博客
03-03 3645
Linux-基础IO一级目录二级目录三级目录 文件的宏观理解： 狭义理解： 文件在磁盘里 磁盘是永久性存储介质 磁盘是外设（即是输出设备也是输入设备） 对文件的所有操作，都是对外设的输入和输出 简称IO 广义理解： Linux下一切皆文件（键盘、显示器、网卡、磁盘……这些都是抽象化的过程） 文件操作的归类认知： 对于0KB的空文件是占用磁盘空间的 文件是文件属性（元数据）和文件内容的集合（文件=属性（元数据）+内容） 所有的文件操作本质是文件内容操作和文件属性操作 系统角度： 对文件
【笔记】微机原理及接口技术2 -- 存储器与IO接口技术
delete_you的博客
05-31 1921
微机原理及接口技术课本知识笔记介绍第二步 存储器与IO接口技术
高级 IO(非阻塞、多路复用、异步、存储映射、文件锁)
zhuguanlin121的博客
06-03 458
本小节我们将分别演示使用阻塞式I/O 和非阻塞式I/O 对文件进行读操作，在调用open()函数打开文件时，参数flags指定O_NONBLOCK 标志，open()调用成功后，后续的I/O 操作将以非阻塞式方式进行；这就是非阻塞I/O 的打开方式，如果参数flags未指定O_NONBLOCK 标志，则默认使用阻塞式I/O 进行操作。 对于普通文件来说，指定与未指定O_NONBLOCK 标志对其是没有影响，普通文件的读写操作是不会阻塞的，它总是以非阻塞的方式进行I/O 操作，这是普通文件本质上决定的。..
容器与IO流刍议
qq_39939939的博客
05-02 185
容器 一.何为容器 java提供了用于开发桌面程序的API（Application Programming Interface，应用程序接口），并存储在javax.swing包中。java.swing是一个非常强大的包，内容相当丰富。 通过GUI（Graphics User Interface,图形用户界面），用户可以和程序之间进行交流。java的抽象窗口工具包（Abstract Window Toolkit，AWT）提供了许多用来设计GUI的类，早期进行设计时主要使用的 包是java.awt包提供
io流中的锁
qq_33790251的博客
11-15 924
io流中的一些类中都是有锁操作的 今天记录一种 inputstream对象是文件输入流 先被缓冲流BufferedReader装饰着包装使用 之后在直接使用unputstream对象进行读操作 发现读不出来 原因是上面缓冲流的使用已经将其加了锁 直到下边直接使用的时候 还没有进行释放 @503可以看出是同一个对象 先注掉上面的缓冲流读取 下边就能够读出来了。上图中的...
LINUX基础——标准IO
bx1091182836的博客
02-06 545
本文主要介绍标准IO的相关概念、缓冲区、FILE指针和流、标准IO相关函数等。
【深入理解 Linux 的 I/O 系统】
Sugar_wolf的博客
05-31 258
【深入理解 Linux 的 I/O 系统】
Linux - 第23节 - Linux高级IO（一）
qq_45113223的博客
06-05 646
• 接下来我们需要将读取上来的数据包交给最底层的链路层处理，进行链路层的解包和分用，此时就是让sk_buff结构当中的mac_header指针指向最初的数据包，然后向后读取链路层的报头，剩下的就是需要交给网络层处理的有效载荷了，此时便完成了链路层的解包，。• 紧接着就是传输层对数据进行处理了，同样的道理，让sk_buff结构当中的transport_header指针，指向数据包中网络层报头之后的数据，然后继续向后读取传输层的报头，便完成了传输层的解包。
Linux--基础IO
weixin_52669146的博客
10-27 2521
系统调用接口、文件描述符的本质
java jdk-api-1.6 中文 chmd
03-22
java.io 通过数据流、序列化和文件系统提供系统输入和输出。 java.lang 提供利用 Java 编程语言进行程序设计的基础类。 java.lang.annotation 为 Java 编程语言注释设施提供库支持。 java.lang.instrument 提供...
(重要)AIX command 使用总结.txt
12-25
#如何取定文件与文件集的对应关系,有时想使用某个安装文件, 但没有安装包含该文件的文件集,找到文件集来安装所需文件 首先确认系统中已经安装了“bos.content_list”文件集(fileset), 如果没有安装, 请使用smitty ...
JAVA_API1.6文档（中文）
04-12
java.io 通过数据流、序列化和文件系统提供系统输入和输出。 java.lang 提供利用 Java 编程语言进行程序设计的基础类。 java.lang.annotation 为 Java 编程语言注释设施提供库支持。 java.lang.instrument 提供...
网管教程 从入门到精通软件篇.txt
04-25
ASF：Microsoft高级流媒体格式文件 ASM：汇编语言源文件，Pro/E装配文件 ASP：动态网页文件；ProComm Plus安装与连接脚本文件；Astound介绍文件 AST：Astound多媒体文件；ClarisWorks“助手”文件 Axx：ARJ压缩...
七、文件IO——I/O处理方式和文件锁
dongbipi3785的博客
05-16 158
7.1 I/O 处理方式 7.1.1 I/O处理的五种模型 阻塞I/O模型 若所调用的 I/O 函数没有完成相关的功能就会使进程挂起，直到相关数据到达才会返回。如 终端、网络设备的访问。　　 非阻塞模型 当请求的 I/O 操作不能完成时，则不让进程休眠，而且返回一个错误。如 open read write 访问 I/O 多路转接模型 如果请求...
Mysql 4 【存储引擎，索引，锁 ，缺集群】
weixin_41431242的博客
10-14 196
一、 存储引擎 体系结构详解 客户端连接 支持接口：支持的客户端连接，例如C、Java、PHP等语言来连接MySQL数据库 第一层：网络连接层 连接池：管理、缓冲用户的连接，线程处理等需要缓存的需求。 例如：当客户端发送一个请求连接，会从连接池中获取一个连接进行使用。 第二层：核心服务层 管理服务和工具：系统的管理和控制工具，例如备份恢复、复制、集群等。 SQL接口：接受SQL命令，并且返回查询结果。
oracle rac IO 隔离的存储SCSI锁原理
hugh 's Oracle 10g blog
06-02 1983
SCSI锁的作用: 在一个共享存储的环境下，多台前端主机可能会同时访问同一台存储设备，如果此时多台主机在同一时点上对一个LUN进行写操作，那么可想而知这个LUN将不知道哪个数据先写，哪个数据后写。为了防止这种情况发生而导致的数据损坏，所以就有了SCSI锁的概念。通过SCSI Reservation机制来进行SCSI锁的操作，目前绝大多数的磁盘都支持‘SCSI reservvation命令‘。
Linux 性能分析之 IO 篇
tecoes的博客
06-08 3334
这个值越大，说明产生的 IO 请求较多，IO 压力较大，我们可以结合 %idle 参数来看，如果 %idle < 70% 就说明 IO 比较繁忙了。rrqm/s 和 wrqm/s：分别每秒进行合并的读操作数和写操作数，这是什么意思呢，合并就是说把多次 IO 请求合并成少量的几次，这样可以减小 IO 开销，buffer 存在的意义就是为了解决这个问题的。一般这几个值偏大，都意味着系统 IO 的消耗较大，对于读请求较大的服务器，b、bo、wa 的值偏大，而写请求较大的服务器，b、bi、wa 的值偏大。
【Linux系统编程：基础IO 上】简单复习C语言文件接口 | 学习系统文件接口 | 认识文件描述符 | Linux下，一切皆文件 | 重定向原理
wh128341的博客
07-20 1640
关于进程，我们还要再往下学习进程间通信、进程信号，但是在这之前，我们先学习基础IO，这篇文章穿插在进程中并不奇怪，因为它有着承上启下的作用。文件的宏观理解那么文件在哪呢？——广义上理解，键盘、显示器等都是文件，因为我们说过“Linux下，一切皆文件”，当然我们现在对于这句话的理解是片面的；狭义上理解，文件在磁盘上，磁盘是一种永久存储介质，不会受断电的影响，磁盘也是外设之一，所以对文件的所有操作，都是对外设的输入输出，简称IO(Input、Output)。文件的组成。.........
学习-java输入输出之随机io流之向文件中追加内容
最新发布
06-28
向文件中追加内容可以使用Java中的随机IO流。具体步骤如下： 1. 创建一个File对象，指定要操作的文件路径。 2. 创建一个RandomAccessFile对象，指定文件对象和打开模式为“rw”。 3. 将文件指针移动到文件末尾，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值