一、page cache

操作系统为程序分配内存并不是按照一个一个来字节分配的，而是把整个内存切分成一个一个小的4k的内存块来分配的。这样一个个小的4k内存块，被称为page，操作系统这样的做的目的是为了提升性能。linux可以通过“_getconf PAGESIZE_”命令来查看系统数设置的page大小。
image.png
操作系统往文件中写入数据时为了提高性能不会直接往硬盘中写入，而是先往内存中写入数据，而内存又被拆成一个个page，等page达到一定的占用比率才会通过LRU或者LFU的算法找出该删掉的page，然后再把page中的数据一次性地写入磁盘中。这种内存临时存储硬盘的数据的page，被称为page cache。 但是page cahe有一个致命的问题, 就是内存的存储是临时的，一旦遇到断电异常会直接丢失内存中的数据。

二、ByteBuffer、RandomAccessFile

  1. import org.junit.Test;
  2. import java.io.BufferedOutputStream;
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  5. import java.io.RandomAccessFile;
  6. import java.nio.ByteBuffer;
  7. import java.nio.MappedByteBuffer;
  8. import java.nio.channels.FileChannel;
  10. public class OSFileIO {
  12.     static byte[] data = "123456789\n".getBytes();
  13.     static String path =  "/root/testfileio/out.txt";
  16.     public static void main(String[] args) throws Exception {
  19.         switch ( args[0]) {
  20.             case "0" :
  21.                 testBasicFileIO();
  22.                 break;
  23.             case "1":
  24.                 testBufferedFileIO();
  25.                 break;
  26.             case "2" :
  27.                 testRandomAccessFileWrite();
  28.             case "3":
  29. //                whatByteBuffer();
  30.             default:
  32.         }
  33.     }
  36.     //最基本的file写
  38.     public static  void testBasicFileIO() throws Exception {
  39.         File file = new File(path);
  40.         FileOutputStream out = new FileOutputStream(file);
  41.         while(true){
  42.             Thread.sleep(10);
  43.             out.write(data);
  45.         }
  47.     }
  49.     //测试buffer文件IO
  50.     //  jvm  8kB   syscall  write(8KBbyte[])
  52.     public static void testBufferedFileIO() throws Exception {
  53.         File file = new File(path);
  54.         BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
  55.         while(true){
  56.             Thread.sleep(10);
  57.             out.write(data);
  58.         }
  59.     }
  63.     //测试文件NIO
  66.         public static void testRandomAccessFileWrite() throws  Exception {
  69.         RandomAccessFile raf = new RandomAccessFile(path, "rw");
  71.         raf.write("hello mashibing\n".getBytes());
  72.         raf.write("hello seanzhou\n".getBytes());
  73.         System.out.println("write------------");
  74.         System.in.read();
  76.         raf.seek(4);
  77.         raf.write("ooxx".getBytes());
  79.         System.out.println("seek---------");
  80.         System.in.read();
  84.         FileChannel rafchannel = raf.getChannel();
  85.         //mmap  堆外  和文件映射的   byte  not  objtect
  86.         MappedByteBuffer map = rafchannel.map(FileChannel.MapMode.READ_WRITE, 0, 4096);
  89.         map.put("@@@".getBytes());  //不是系统调用  但是数据会到达 内核的pagecache
  90.             //曾经我们是需要out.write()  这样的系统调用，才能让程序的data 进入内核的pagecache
  91.             //曾经必须有用户态内核态切换
  92.             //mmap的内存映射，依然是内核的pagecache体系所约束的！！！
  93.             //换言之，丢数据
  94.             //你可以去github上找一些 其他C程序员写的jni扩展库，使用linux内核的Direct IO
  95.             //直接IO是忽略linux的pagecache
  96.             //是把pagecache  交给了程序自己开辟一个字节数组当作pagecache，动用代码逻辑来维护一致性/dirty。。。一系列复杂问题
  98.         System.out.println("map--put--------");
  99.         System.in.read();
  101. //        map.force(); //  flush
  105.         raf.seek(0);
  107.         ByteBuffer buffer = ByteBuffer.allocate(8192);
  108. //        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
  110.         int read = rafchannel.read(buffer);   //buffer.put()
  111.         System.out.println(buffer);
  112.         buffer.flip();
  113.         System.out.println(buffer);
  115.         for (int i = 0; i < buffer.limit(); i++) {
  116.             Thread.sleep(200);
  117.             System.out.print(((char)buffer.get(i)));
  118.         }
  121.     }
  124.     @Test
  125.     public  void whatByteBuffer(){
  127. //        ByteBuffer buffer = ByteBuffer.allocate(1024);
  128.         ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
  131.         System.out.println("postition: " + buffer.position());
  132.         System.out.println("limit: " +  buffer.limit());
  133.         System.out.println("capacity: " + buffer.capacity());
  134.         System.out.println("mark: " + buffer);
  136.         buffer.put("123".getBytes());
  138.         System.out.println("-------------put:123......");
  139.         System.out.println("mark: " + buffer);
  141.         buffer.flip();   //读写交替
  143.         System.out.println("-------------flip......");
  144.         System.out.println("mark: " + buffer);
  146.         buffer.get();
  148.         System.out.println("-------------get......");
  149.         System.out.println("mark: " + buffer);
  151.         buffer.compact();
  153.         System.out.println("-------------compact......");
  154.         System.out.println("mark: " + buffer);
  156.         buffer.clear();
  158.         System.out.println("-------------clear......");
  159.         System.out.println("mark: " + buffer);
  161.     }
  164. }