章节一：文件IO

call  read(fd8)

app2

postion

字节数组对象off heap

每次切换均存在寄存器保护该应用程序现场  

[root@huang /]# read a 0< huang.txt与read a <& 8的区别原先read a这个命令 需要等待键盘输入 键盘输入也是输入到0<中  也就是通过bash这个程序自有的文件描述符接受键盘数据   现在使用huang.txt用作数据源[root@huang /]# ls ./ /huanbgls: cannot access /huanbg: No such file or directory./:$    boot  etc   huang.txt  lib64    ls01.out  media  niu.out  proc  run   src  sys         tmp  var  zhao.outbin  dev   home  lib        liu.txt  ls02.out  mnt    opt      root  sbin  srv  testIO.txt  usr  www  zhao.txt此时输出分别使用了1u 2u 输出[root@huang /]# ls ./ /huanbg  1>test.txt   2>error.txt

疑问：通过app程序创建的FD 如何与pagecache勾搭上的   File file = new File(\"xxoo.txt\")out=new OutPutStream（file）;//out 在操作系统层面为文件描述符FD

DMA协处理器

3

挂载：访问目录的时候相当于访问这块物理硬盘

父子进程

⑤：app挂起状态到可运行转态

一个线程的成本：①：基于jvm的一个线程对应一个栈 如果一个栈大小为1M 当1000个线程出现的时候占用内存1G②:关于栈 在运行时常量池 当有线程开启的时候会创建一个栈 栈只有等方法执行结束之后才会失效 所以开启的线程会一直挂起，线程的执行是通过时间分片执行 线程的切换也是需要时间 线程高度会导致cpu频繁调度③：几核cpu 几个线程  4核cpu     意思为：4核cpu表示可以同时并行处理4个线程所以应该控制线程数量

①：system call读取磁盘数据

code

flip的时候

程序角度

running状态

栈

内核空间

int ox80为中断 表示int为cpu指令0x80为128对应二进制 1000 0000该二进制存放寄存器

MappedByteBuffer

蓝线为请求获取数据的流程

分配的时候

flush写回脏页

性能：onheap  < offHeap  < mappedByteBuffer(这里仅在文件中使用)

综合：多机 多副本 性能差不多即可

物理内存：真实内存条中存储的数据

0

一台机器上安装一个Redis实例 分配10G内存 和安装10个实例 每个实例1G内存的区别：AKF集群拆分原则  Y轴的拆分(微服务涉及)

操作系统进程分配

PageCache主要目的也是充当缓存

协处理器在数据读取完毕之后发送的中断

app1

[root@huang demo]# pstree  //执行pstree这个程序├─sshd─┬─sshd───bash───pstree上述bash为父进程 (pstree为在父进程的创建子进程)父进程为/bin/bash可执行文件       [root@huang fd]# pcstat -pid $$ [root@huang fd]# pcstat -pid $$  +--------------------------------------+----------------+------------+-----------+---------+| Name                                 | Size (bytes)   | Pages      | Cached    | Percent ||--------------------------------------+----------------+------------+-----------+---------|| /usr/bin/bash                        | 960377         | 235        | 235       | 100.000 || /usr/lib/locale/locale-archive       | 106176928      | 25923      | 512       | 001.975 || /usr/lib64/libnss_files-2.17.so      | 61560          | 16         | 16        | 100.000 || /usr/lib64/libc-2.17.so              | 2156240        | 527        | 527       | 100.000 || /usr/lib64/libdl-2.17.so             | 19248          | 5          | 5         | 100.000 || /usr/lib64/libtinfo.so.5.9           | 174520         | 43         | 43        | 100.000 || /usr/lib64/ld-2.17.so                | 163312         | 40         | 40        | 100.000 || /usr/lib64/gconv/gconv-modules.cache | 26970          | 7          | 7         | 100.000 |+--------------------------------------+----------------+------------+-----------+---------+ [root@huang fd]# pcstat /bin/bash+-----------+----------------+------------+-----------+---------+| Name | Size (bytes) | Pages | Cached | Percent ||-----------+----------------+------------+-----------+---------|| /bin/bash | 960377 | 235 | 235 | 100.000 |+-----------+----------------+------------+-----------+---------+ 

磁盘io/网络io第二节

capacity

pipeline管道

在{}中存放许多指令使用;隔离 可以一次性执行

NIO与之前的缓冲和基本区别

关于D:\\huangproject\\bjmashbing-sysio-master\\bjmashbing-sysio-master\\src\\main\\java\\com\\bjmashibing\\system\\io\\OSFileIO.java①：普通字节流  当前后台dirty_background_radio和dirty_radio阈值较高的时候 发生宕机情况 此时来不及flush书写会磁盘 容易丢失较多数据   //执行pcstat 后面的precent均是100%   ②：buffer字节流   与上面的基本字节流相比  (stream均是字节流)buffer要快 的原因：用户态和内核态切换频率不一样，buffer在jvm中的APP缓冲区开辟一个8k的空间用于缓存发送的数据  虽然存在write(data)但是并没有直接交给内核                              而是交给了一个容量为8k的缓存(该容器为数组)，在8k满了之后执行一次系统调用                                而对于基本字节流 每次write(data)的时候会执行一次系统调用                                                  // 此时执行pcstat 后面的+---------+----------------+------------+-----------+---------+   pcstat out.txt| Name    | Size (bytes)   | Pages      | Cached    | Percent ||---------+----------------+------------+-----------+---------|| out.txt |       540540         |  132   |   132      | 100.000 |+---------+----------------  +------------+-----------+---------+      

当读取的时候 将postion回到0   limit等于之前的postion

对于kenel:存在一个vfs(虚拟文件系统) 结构为树 树上的不同节点映射到不同的物理位置，每个物理位置可以是不同的具体文件系统eg:挂载磁盘的时候 需要更新vfsvfs结构：（inode pagecache dirty）存在一个inode(eg:打开磁盘的时候每个文件对应一个inode（看成id）)来代表这个在磁盘上的文件，此时app程序想读取硬盘数据的时候 先有kenal去读取到内存(内存存储临时数据通过pagecache来保存默认4k) 该pagecache在内存中可以给多个用户app共享dirty:如果程序将磁盘中的文件读取到内存中且用pagechache缓存了，此时用户app更改了某个pagecache中的数据，那么将该pagecache标记为dirtyflush：当内存中的pagechache被标记为dirty之后，可以通过flush将已修改的pagechache回写保存到磁盘中

此时想读取fd8这个文件描述符

保护现场：在用户态转为内核态的时候发送

[root@huang temp]# a=1[root@huang temp]# { a=9 ; echo \"aaaaa\"; } | cat//此时这里echo具有输出能力 通过管道将其输出结果作为管道的cat输入aaaaa[root@huang temp]# { echo $a ; echo \"aaaaa\"; } | cat1aaaaa [root@huang temp]# { a=9 ; echo \"aaaaa\"; } | cataaaaa[root@huang temp]# echo $a//这里为什么是1？ 原因bash解释执行 分词分析看到  |  管道此时在左侧和右侧分别启动一个子进程1 此时a=9为子进程赋值 父进程打印a还是等于1[root@huang temp]# echo $BASHPID | cat //在管道中获取进程id号需$BASHPID25797 [root@huang temp]# { echo $BASHPID ; read a; } | { cat ; echo $BASHPID ; }26643111  //read在么有换行符的时候会阻塞等待26644 执行流程为 解释执行想看到 管道|  左侧创建一个子进程 打印26643 之后等待输入111 左侧二个指令均存在输入和输出所以通过管道将左侧的输出 作为右侧进程的输入cat  打印出26643和111 之后执行 

kernel进程

JVM为代码   运行的时候会分配出堆

free的使用

nio新的io体系存在二个概念①：channel和bytebuffer在没有抽象出channel之前存在输入和输出（outputstream和inputstream）:抽象出channel之后 只需要一个channel完成输入和输出（基于buffer 在buffer基础上扩展出 MappedByteBuffer和directbuffer ）bytebuffer看成字节数组：      ByteBuffer buffer = ByteBuffer.allocate(1024);//分配方式一 分配到堆上        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);//分配方式二  分配到堆外     存在  属性        postion          limit            capacity             buffer.put(\"123\".getBytes());       buffer.flip();   //读写交替       buffer.get();      buffer.compact();     buffer.clear();

这里的bytebuffer充当的依然是缓冲区；需要创建FD 建立channel完成读写

https://blog.csdn.net/wangfeng2500/article/details/42821297

磁盘

验证

存放code

需要channel.readchannel.write必然存在系统调用

ps -ef的使用  ps-ef |grep 554433 查看进程

pos

指令块

centos中的sysctl  -a的使用[root@huang fd]# sysctl -a | grep vm.dirtyvm.dirty_background_bytes = 0//background_radio和dirty_ratio    这里设置是保证内存的利用率 不会将所有的内存用于存储pagecache vm.dirty_background_ratio = 10   //假设kernel中假设可用还有10G内存 在从磁盘读取数据到内核 达到1G的时候   此时程序不会阻塞 而是使用剩下的9G   继续从磁盘读取写到内存    且还会分配一个线程回写脏页到磁盘    比率越高断电宕机的时候丢失的越多vm.dirty_bytes = 0vm.dirty_expire_centisecs = 3000//均是除以100  过期时间    该pagecache 30秒不用就回写vm.dirty_ratio = 30                       //这个为前台 还是程序在往内核书写 到3G的时候 阻塞程序 此时会将脏页的数据写回到磁盘上 减少pagecache占用的空间 (这个在)vm.dirty_writeback_centisecs = 500 //管道：原先sysctl存在输入输出 -a为输入 输出全部的centos参数  流向管道经过过滤出包含vm.dirty 输出  管道在词法解析 解释执行 看到 | 则通过父进程bash创建左右二个子进程 

堆

kernel内核

③

概念

内核中的中断向量表(0--255)为表结构 存在key ---valuekey为1000 0000 value为call  back(该地址为一个在内核中的函数)比如正常关机的时候 产生中段 调用内核关机（会存在dirty pagecahe回写的过程）直接关机 dirty会丢失

下面的所有pageCache是内核维护的

①：allocate Direct    如果存在一个object对象 该对象是我自己写的 可以使用堆外的 也就是该对象本人可以控制  ；也就是(在方法中传入一个object  做序列化转成字节数组)②：allocate  如果该object

磁盘硬件

dd命令的使用dd if=/dev/sda3  of=./sda3.bak.img 相当于将sda3这个源 做了一个压缩文件的一个备份dd if=/dev/zero  of=./sda3.bak.img  //将.img用0填充 创建空的磁盘对象源 目标硬盘 硬盘 拷贝文件 硬盘 恢复（将文件中的数据拷贝到硬盘）硬盘 文件 备份

system call系统调用

D:\\huangproject\\io

put的时候

这里缓存了100% 已将bash这个程序从磁盘完全读取到程序内存中的文本中 并且缓存

pipeline应用及重定向机制

//原因$$的优先级高于管道 此时先执行$$  然后将pid替换$$   在执行管道左右各创建一个进程 将具体的pid指向cat对于$BASHPID而言 优先级低于 | 先创建子进程 将子进程pid替换$BASHPID 在创建右侧的子进程 将具体的pid流向cat

启动java代码   java  xxxx  -Xmx 1G此时启动java  创建进程 分配内存  (该空间内核态和用户态均可以访问)此时xxxx  -Xmx 1G为在jvm中分配的堆内存 仅仅可以用户态访问  所以通过allocate分配的数组对象需要用户态到内核态的切换而在off heap上的通过allocateDirect分配的不需要经过内核态和用户态的切换（原因：对于c程序来说访问off heap中的数据是直接访问  原因该off heap所在的地址就是进程的线性地址空间）=====》从off heap到kernelpagecache依然存在系统调用但是onheap的地址不在进程的线性地址空间中(存在于jvm线性地址空间) 所以对于c程序而言 访问该字节数组 需要先拷贝到进程分配的堆内存 才可以使用-----》以后的零拷贝====》从on heap到kernelpagecache依然存在系统调用 且还需要将jvm堆中的拷贝到off heap对于MappedByteBuffer 该区域的逻辑地址直接映射到内核的逻辑地址  此时无需系统调用

为strace追踪的应用程序对内核的系统调用  每一行均是一次系统调用

此时app程序读取数据从内存中的pagechache中读取，当再次读取的时候效率很高，在修改某一个pagecache之后，该pg标记为dirty

app1该程序也是碎片化存在于物理内存  通过mmu将其映射为逻辑内存（此时由原先存在于物理内存中碎片变为线性的地址，也就是该程序在逻辑地址中占用的空间时连续的 每个内存地址均是4K）注意这里不是全量加载 当缺页的时候依然需要中断 去磁盘加载放到pagecache中；这里的程序也是用户态的，在需要执行的时候该app的时候 先从磁盘加载程序代码（也是基于pagecache的）此时并不是全量加载，懒加载：当执行代码片段缺页的时候 也会发生中断 由用户态到内核态切换 通过内核态查找使用存在该pagecache是否存在 不存在则需要通过协处理去磁盘：整个过程依然遵循 用户态到内核态切换的五个步骤

jvm中的heap

d被标记为dirty的pg回写会磁盘

limit

pagecache

pagecache粗俗的理解

验证：基本输出流  缓存输出   用户态到内核态的切换

FD

buffer

关于swap(存在于磁盘中)  如果内存是一个G 但是内存中所有在运行的程序 占用的空间可以大于1G：原因就在于swap的使用  也就是当前没有正在使用的程序存放在swap区域中，由于进程也是存在时间分片的概念 所以当在内存中运行的程序 不在使用了，现在使用了swap中存放的app那么整个系统会卡顿一下（用于将swap的交换到内存）

1

当将需要的数据读取完毕全部缓存到内存中的pagecache中之后，协处理器也会存在一个中断  此时再讲app1的进程转态改为可运行转态

文件IO：基本流    缓冲流   bytebuffer   直接内存 的使用Socket网络编程IO: 阻塞BIO  非阻塞NIO  多路复用器(可以通过参数配比要求JDK使用epoll还是poll)   netty                             epoll如何知道数据到达？还是中断写时复制

文件类型：-  ：普通文件（可执行文件 图片 文本）D:目录b:块设备  读取的时候可以读取到该去的和当前的 存在偏移量 选择性读取(硬盘)c:字符设备  读取的时候只能读取当前的  (键盘 摄像头 网卡)s: sokectp:pepline 管道eventpoll:  为内核提供的epol内存区域l:链接 软连接和硬链接硬链接：[root@huang test]# ln ./huag.txt(源) ./huangs.txt(目标)创建完毕之后-rw-r--r--. 2 root root 15 Aug 12 05:05 huag.txt-rw-r--r--. 2 root root 15 Aug 12 05:05 huangs.txt2表示相关联的  且修改huangs.txt  huag.txt也会更改  删除任何一个另一个还会存在此时查看硬链接的stat 二个均查看 发现inode号码一致，每个文件均存在一个INODE  硬链接为二个一个绝对路径为变量名执行同一个磁盘的物理位置软连接:[root@huang test]# ln -s huangs.txt hu.txtlrwxrwxrwx. 1 root root 10 Aug 12 05:32 hu.txt -> huangs.txt软连接的二个文件的inode不一样 

内存

java使用c语言系开发的程序

总结  执行java 启动该进程

执行二进制文件 -Xmx1G （不给这个参数就是用默认的参数）

kernel

io设备(磁盘，鼠标，网卡等)

1         2        3

kenel操作系统内核（程序）

app程序

上面用户空间的该部分逻辑地址直接映射到kernel内存的pagecahceh逻辑地址同时也是直接映射到磁盘文件

硬件角度

当出现Pages>Cached的时候表示  pages为out.txt可拆分的大小  Cached表示内存可缓存的大小，那么此时那么肯定存在向磁盘写的过程(通过dirty_background_radio和dirty_radio) 写完后的Cached会通过lru淘汰回收淘汰时机为更具lru算法 会优先处理在内存时间久的pc  此时就会出现第一次写到xxoo.txt的放到磁盘中 以及出现precent不是100%(也就是可拆分出的4k大于可被内存缓存的cached) 当书写out.txt的时候 上面xxoo.txt的precent持续降低 原因就是lru算法特点 优先处理时间久的脏页 -----》此时根据dirty_background_radio 的比率在达到设置的阈值为10%的时候 会先将标记dirty的pc  回写到磁盘，此时的pagecache没有dirty 但是依然缓存之前的数据  此时会根据lru算法 将其淘汰    dirty_background_radio 不会阻塞 依然可以分配pagecache动态 之前的根据lru动态删除     dirty_radio为防止增长过快 此时阻塞不容许在书写可以通过用户调用flush将pagecache中的脏页会写到磁盘，但是 如果pc原先是4k  但是仅仅保留了1k  也会将整个4k全部回写到磁盘

此时jvm在磁盘中

关于何时使用上述三种

用户空间

pcstat的使用

$1  表示执行./mysh.sh  1   后面的1为参数  $0表示的是./mysh.sh

上述二种仅仅是分配了字节数组 可以填充；span style=\"font-size: inherit;\

PS为进程

从低地址到高地址分别内存区分别为：代码段、数据段（初始化）、数据段（未初始化）（BSS）、堆、栈、命令行参数和环境变量。其中，堆向高内存地址生长，栈向低内存地址生长。字啊系统新建一个进程的时候32位的操作系统会分配4G的内存 0-3G内核态和用户态均可以访问3g-4g仅内核态可以访问

[root@huang ~]# exec 8<> huang.txt  8u终端为huang.txt

[root@huang fd]# vim /etc/sysctl.conf 修改上述参数    sysctl -p执行让其生效

使用rafchannel.map方式创建

对于bytebuffer而言  相当于存在三个指针的数组

落地实现：netty(onheap  offheap(侧重于))   为什么netty没有使用mappedByteBuffer

上一章节的补充

/bin  原先的path中就包含bin目录  当执行命令的时候 原先就会在path目录中寻找所以可以将pcstat放到/bin目录下 

只有内核才可以直接操作磁盘和网络还是pagecache体系

此时使用了bytebufferByteBuffer.allocate(8192);方式创建的 直接将字节数组分被到jvm堆上

stack

kenel

cpu+内存+硬盘+其他设备

sokcet应用

查看文件的源数据信息：包含INODE[root@huang test]# stat huangs.txt  File: ‘huangs.txt’  Size: 20         Blocks: 8          IO Block: 4096   regular fileDevice: fd00h/64768d Inode: 412442(stat也属于用户程序 执行的时候 也需要从内存中获取)      Links: 1(如果存在链接则为2)Access: (0644/-rw-r--r--)  Uid: (    0/    root)   Gid: (    0/    root)Context: unconfined_u:object_r:admin_home_t:s0Access: 2021-08-12 05:12:28.041596076 -0400Modify: 2021-08-12 05:12:28.041596076 -0400Change: 2021-08-12 05:12:28.116596542 -0400 

cpu 读取程序中的指令执行

//该进程下的pagecache

1被get了

关于启动程序主线程的out的解读

pagecache存储在kernel中 做缓存，通过App的FD(使用迭代器模式 存在偏移量最终回去自己程序想要的那部分数据，在操作同一个pagecache的时候需要使用锁)

为什么使用堆外？

对于重定向的不需要书写&（由原先的默认流向）如果流向文件描述符 <>右侧+&

strace -ff -o out   java   xxx.class  args[0]参数的使用   输出的out为发生系统调用的线程

关于io阻塞：对于app1和app2 二个程序（进程是有状态的）cpu调度 存在运行状态和

字节数组对象on heap

cpu

heap操作系统进程分配

中断机制：开始执行的是App程序；当系统调用的时候该运行的App程序中断 （保护app程序现场 从用户态切换到内核态）去执行内核中的程序

jps查看java程序        55848 Jpskill -9 进程id  //销毁这个进程

协处理器的寄存器从硬盘读数据

txt文本区

从硬盘读取数据通过协处理器的寄存器

pagecache 4K

byte b = buffer.get();        System.out.println((char)b);单字节变为字符打印 原先输出对应的acsll码

FD指针seek(偏移量)

操作系统 没有绝对的数据可靠性 均是基于pagecache体系  ； 存在pagecache的原因是减少硬件IO的调用  优先使用内存  提高效率所以在追求性能的时候 需要在 可靠性 一致性  可用性 做权衡，即使要求高可靠性  (flush较多 此时的性能最差) 但是单点问题会让 该可用性完犊子（主从复制  主备HA）这也就是kafka和es 均存在副本的概念(通过socket得到的)

将需要的数据读取到内存，在内存中通过pagecache缓存

当写入的时候  移动postion   limit与capacity一个位置

使用lru淘汰算法

挂起转态：也就是 该app不在系统内核进程调度队列中此时会调用其他进程

线程

测试结果

①：buffer缓冲②：pagecache缓冲  不会主动释放占用的的内存 比较费内存③：磁盘缓冲区

基于文件的nio

compact

[root@huang temp]# echo $$19961[root@huang temp]# /bin/bash //在启动一个bash进程 使用exit退出[root@huang temp]# echo $$23727 [root@huang temp]# pstree  //查看进程├─sshd───sshd───bash───bash───pstree                                              19961    23727   //进程的父子关系[root@huang temp]# ps -ef | grep $$UID          PID     PPID     C     STIME     TTY            TIME      CMDroot       19961    19956     0    21:50    pts/0      00:00:00  -bashroot     23843    19961  0    23:03     pts/0       00:00:00     /bin/bashroot     24111 23843  0 23:08 pts/0    00:00:00 grep --color=auto 19961ppid为父进程pid为当前进程 对应后面的程序/bin/bashcmd为执行的命令进程隔离：[root@huang temp]# x=100[root@huang temp]# echo $x100[root@huang temp]# /bin/bash[root@huang temp]# echo $x  //此时由于进程隔离 在该线程下获取不到x的值此时使用export:使得环境变量y有导出能力先退出后面申请的进程 exit[root@huang temp]# export y=50[root@huang temp]# echo $y50[root@huang temp]# /bin/bash [root@huang temp]# echo $y50

0t17

一切皆文件 基于文件应用到I/O流

①：是需要的code文件是懒加载到pagecache中的，也就是code 不是一次性全部加载到内存的pc中  ;②：在发生系统调用的时候 用户态切换到内核态  

②执行读取指令

sokcet和pipeline

app

APP

App结构基于C语言 在内存中的

sysctl -a 显示cenos中的控制项

执行的时候分配出data

④：将需要的数据读取完毕之后，app又重新变为可运行阶段

通过kenel中的vfs找到对应的文件

关于pagecache（内核维护缓存在内存）是否淘汰?是一次性全部加载进来还是懒加载?当程序修改pagecahce中的数据回写磁盘永久化策略?从时间上的立刻回写持久化还是延时持久化(丢失数据的多少)

[root@huang java-1.8.0]# find / -name java//查找文件/home/huang/testosFile

重点：

②：用户态到内核态之间的切换阶段

切换到内核态路径

buffer为引用到缓冲而减少系统嗲用的损耗

恢复到初始状态pos为0  limit=capacity

[root@huang testosFile]# pcstat  -bname  out.txt +---------+----------------+------------+-----------+---------+| Name    | Size (bytes)   | Pages      | Cached    | Percent ||---------+----------------+------------+-----------+---------|| out.txt | 3125060        | 763        | 763       | 100.000 |+---------+----------------+------------+-----------+---------+rm -rf *out*/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-0.el7_8.x86_64/bin/javac OSFileIO.javastrace -ff -o out /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-0.el7_8.x86_64/jre/bin/java OSFileIO 0(0为参数args[0]) ll -h && pcstat out.txtpcstat 后面可以接 名称和pid

df命令：[root@huang ~]# dfFilesystem              1K-blocks    Used Available Use% Mounted on/dev/mapper/centos-root  18307072 4762724  13544348  27% /devtmpfs                   494008       0    494008   0% /devtmpfs                      504636       0    504636   0% /dev/shmtmpfs                      504636    6996    497640   2% /runtmpfs                      504636       0    504636   0% /sys/fs/cgroup/dev/sda1                  508588  129300    379288  26% /boot表示 某个硬件被挂载到vfs中/boot挂载到    /dev/sda1(表示设备硬盘的1分区) 中  这里虽然/挂载到root中仅仅在根目录下的/boot挂载到sda1分区下(覆盖掉原先/下面的boot)之所以覆盖是：加载顺序 先挂载的是/到root中 其中包括boot 之后在挂载/boot的到/dev/sda1z之后覆盖掉/目录中的bootmount  /dev/sda1  /boot 则可以进行挂载 (这里直接将/dev/sda1中存储了内容当挂载到/boot的时候 boot就可以访问了)eg:当上线时间长了之后存放日志文件越来越多，此时可以安装一个硬盘 分区之后先将原先的日志文件内容拷贝到新的硬盘 然后在使用mount /dev/newDisk /log也就是使用型硬盘存放日志文件（与boot一样可覆盖）

一个pagecache在内存一开始申请就是脏页;脏页淘汰前需要回写到磁盘上；该脏页已经写回过磁盘了可以通过lru在内存淘汰掉

kenel程序

①：当访问io设备的硬件的时候流程

③：app进程挂起阶段

通过mmap系统调用创建

txt二进制文件

使用ByteBuffer.allocateDirect(1024);方式创建，将返回的字节数组 分配到java进程的堆空间

如何查看进程 echo $$ 查看当前bash进程id

get的时候

在发生系统调用的时候，触发int80切换到内核态原先在appi内部处理，的那个读取FileInPutStream的对象执行read的时候，那么触发int80，此时保护app1进程现场，进入内核态执行(为什么需要经过cpu? 原因int80为cpu指令 执行该指令此时kernel中存在中断向量表 key为int80对应的二进制，value为call back函数执行 也就是切换到内核态)此时app的转态由原先的Running转态在切换到内核转态之后 保护现场（原先的cpu寄存器的数据保存在app的系统栈中）状态变换为内核态的时候  在kernel执行系统调用读取数据，此时想在pagecache中查找有没有，没有则触发缺页此时在走DMA写处理器（从磁盘读取数据(从磁盘到内存的数据必须经过处理器慢慢捣腾)）

切换到内接态路径

方法区

jvm代码

2

上述为重定向 打破之前默认的标准输入和输出

liunx操作系统的vfs(虚拟文件系统)   输入指令 cd /   ll 打印的就是虚拟文件系统 根目录下的一级目录

这里的put() 不会发生系统调用

NOTE:通过被标识为dirty的pg回写到磁盘文件中的时间和方式决定io模型

[root@huang testosFile]# free                  total          used          free            shared     buff/cache    availableMem:        1009276      157584      311232       10188      540460        612660Swap:        2097148       39596       2057552 free为可用的

运行时数据区data

可用空间

head  xxoo.txt   显示文件的前10行tail xxoo.txt  显示末尾10行head -2 ooxx.txt  显示头文件的前二行但是现在没有指令直接可以显示第8行的，只存在显示前8行，如何处理？[root@huang temp]# head -8 test.txt [root@huang temp]# head -8 test.txt | tail -1管道的应用：前面的输出 作为后面的输入

寄存器

此时可以继续往里面写

磁盘缓冲区

挂起状态:在pc中没有找到数据之后经过协处理器从磁盘读取数据的时候发生

1024

lsof -op jps进程id