pcstat /bin/bash        pcstat:pageCache + stat;询问操作系统内核，bash文件有没有加载(填充)page页

sysctl -a | grep dirty       sysctl -a:显示centos的控制项

vi /etc/sysctl.conf     下面中罗列了要修改的值

sysctl -p    将配置应用

pcstat out.txt
    利用pcstat查看一个文件从0到1的过程，它的缓冲率以及超过内存以后是否会淘汰一些page

ll -h && pcstat out.txt


**再开一个进程执行java程序

./mysh 0

//实验过程太长，没有记录

sysctl -a | grep dirty 的结果：

vm.dirty_background_ratio = 0
vm.dirty_background_bytes = 1048576
vm.dirty_ratio = 0
vm.dirty_bytes = 1048576
vm.dirty_writeback_centisecs = 5000
vm.dirty_expire_centisecs = 30000


修改后的值：

vm.dirty_background_ratio = 90  
vm.dirty_ratio = 90  
vm.dirty_writeback_centisecs = 5000
vm.dirty_expire_centisecs = 30000

//可用内存使用90%后，脏页从内存向磁盘写
vm.dirty_background_ratio = 90  

//程序使用内核可用内存占比90%，程序不再往内核内存中写数据;
//dirty_background_ratio设置的值应小于dirty_ratio设置的值
vm.dirty_ratio = 90  

vm.dirty_writeback_centisecs = 5000  //50秒
vm.dirty_expire_centisecs = 30000   //300秒

mysh文件内容

rm-fr *out*
/usr/java/jdk1.8*/bin/javac OSFileIO.java
strace -ff -o out /usr/java/jdk1.8*/bin/java OSFileIO $1

OSFileIO.java

File ifile = new File("/ooxx.txt");
out = new outputstream(ifile); //伴随out变量，在操作系统中会得到一个fd，并且这个fd还能看到
out.write("123");

@Test
public  void whatByteBuffer(){
    //分配在堆上或堆外，不影响下面api的结果
//        ByteBuffer buffer = ByteBuffer.allocate(1024);//直接分配在堆上
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);//分配在堆外

    //四个指针
    System.out.println("postition: " + buffer.position());
    System.out.println("limit: " +  buffer.limit());
    System.out.println("capacity: " + buffer.capacity());
    System.out.println("mark: " + buffer);

    buffer.put("123".getBytes());

    System.out.println("-------------put:123......");
    System.out.println("mark: " + buffer);

    buffer.flip();   //翻转：为了读写交替

    System.out.println("-------------flip......");
    System.out.println("mark: " + buffer);

    buffer.get();

    System.out.println("-------------get......");
    System.out.println("mark: " + buffer);

    buffer.compact();

    System.out.println("-------------compact......");
    System.out.println("mark: " + buffer);

    buffer.clear();

    System.out.println("-------------clear......");
    System.out.println("mark: " + buffer);

}

运行结果：

postition: 0
limit: 1024
capacity: 1024
mark: java.nio.DirectByteBuffer[pos=0 lim=1024 cap=1024]
-------------put:123......
mark: java.nio.DirectByteBuffer[pos=3 lim=1024 cap=1024]
-------------flip......
mark: java.nio.DirectByteBuffer[pos=0 lim=3 cap=1024]
-------------get......
mark: java.nio.DirectByteBuffer[pos=1 lim=3 cap=1024]
-------------compact......
mark: java.nio.DirectByteBuffer[pos=2 lim=1024 cap=1024]
-------------clear......
mark: java.nio.DirectByteBuffer[pos=0 lim=1024 cap=1024]

//测试文件NIO
    public static void testRandomAccessFileWrite() throws  Exception {
        RandomAccessFile raf = new RandomAccessFile(path, "rw");//读写权限

        //**普通写
        raf.write("hello mashibing\n".getBytes());
        raf.write("hello seanzhou\n".getBytes());
        System.out.println("write------------");
        System.in.read();//目前内容在pagecache中，不在磁盘


        //**随机写
        //seek ,文件描述符FD中的seek指针偏移量
        //大数据中HDFS也有seek，支撑起了分布式并行计算；
        // 因为每一个程序打开相同的文件，它们各自seek到自己的数据段里，去并行拿到自己的n份数据，并进行计算
        raf.seek(4);
        raf.write("ooxx".getBytes());
        //内容变成
        //hellooxxshibing
        //hello seanzhou

        System.out.println("seek---------");
        System.in.read();

        //**堆外映射写
        //只有文件通道(FileChannel)有map()方法；文件是块设备，可以自由寻址，
        // socket或serverSocket是没有map方法的，因为是字符设备，不能自由漂移
        FileChannel rafchannel = raf.getChannel();
        //map方法通过 系统调用mmap 得到 堆外的 和文件映射的 ByteBuffer
        // byte  not  objtect
        MappedByteBuffer map = rafchannel.map(FileChannel.MapMode.READ_WRITE, 0, 4096);

        //这就是IO模型，再学完socket，简历上可以写“精通IO模型”
        map.put("@@@".getBytes());  //不是系统调用  但是数据会到达 内核的pagecache
            //曾经我们是需要out.write()  这样的系统调用，才能让程序的data 进入内核的pagecache
            //曾经必须有用户态内核态切换
            //mmap的内存映射，依然是内核的pagecache体系所约束的！！！
            //换言之，丢数据
            //也就是说使用JDK的api是无法绕过内核的pagecache，哪怕是unsafe方法
            //你可以去github上找一些 其他C程序员写的jni扩展库，使用linux内核的Direct IO
            //直接IO是忽略linux的pagecache
            //忽略linux的pagecache不是真的忽略，而是把pagecache  交给了程序自己开辟一个字节数组当作pagecache，动用代码逻辑来维护一致性/dirty。。。一系列复杂问题
            //使用linux内核的Direct IO,不像内核的参数修改是全局的，可以做到细粒度的控制；
            //DB数据库会使用linux内核的Direct IO

        System.out.println("map--put--------");
        System.in.read();
        //文件内容：
        //@@@looxxshibing
        //hello seanzhou
        //文件大小变成了4096
        //文件描述符的结果：图片205.png

//        map.force(); //  类似flush

        raf.seek(0);

        ByteBuffer buffer = ByteBuffer.allocate(8192);
//        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

        int read = rafchannel.read(buffer);   //相当于buffer.put()，往buffer中put内容
        System.out.println(buffer);
        buffer.flip();
        System.out.println(buffer);
        //打印结果：
        //java.nio.HeapByteBuffer[pos=4096 lim=8192 cap=8192]
        //java.nio.HeapByteBuffer[pos=0 lim=4096 cap=8192]
        //@@@looxxshibing
        //heool seanzhou

        for (int i = 0; i < buffer.limit(); i++) {
            Thread.sleep(200);
            System.out.print(((char)buffer.get(i)));
        }
    }