网络I/O与磁盘I/O

最新推荐文章于 2023-12-19 07:50:37 发布
最新推荐文章于 2023-12-19 07:50:37 发布
阅读量947 收藏 8
点赞数
分类专栏： java 文章标签： 网络 I/O
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cool_Pepsi/article/details/129785193
版权

目录

一、同步&异步 阻塞&非阻塞

参考：同步、异步、阻塞、非阻塞

同步和异步指的是：当前线程是否需要等待方法调用执行完毕

  • 同步：指的是调用这个方法，你的线程需要等待这个方法执行完成才返回结果，接着再继续执行剩下的代码逻辑
  • 异步：调用这个方法，立马就直接返回，没有返回结果，可以立马执行后面的代码逻辑，然后利用回调或者事件通知的方式得到结果。

阻塞和非阻塞指的是：当前接口数据还未准备就绪时，当前线程是否被阻塞挂起

  • 阻塞挂起：当前线程还处于 CPU 时间片当中，调用了阻塞的方法，由于数据未准备就绪，则时间片还未到就让出 CPU。所以阻塞和同步看起来都是等，但是本质上它们不一样，同步的时候可没有让出 CPU。
  • 非阻塞：当前接口数据还未准备就绪时(例如接口会返回-1)，当前线程不会被阻塞挂起，后续可以不断轮询请求接口，看看数据是否已经准备就绪(是否大于0)

关于 I/O 的阻塞、非阻塞、同步、异步：

  • 阻塞和非阻塞指的是发起 I/O 请求后，用户线程状态的不同，阻塞I/O在数据未准备就绪的时候会阻塞当前用户线程，而非阻塞 I/O 会立马返回一个错误或-1，不会阻塞当前用户线程。
  • 同步和异步是指，内核的 I/O 拷贝实现，当数据准备就绪后，需要将内核空间的数据拷贝至用户空间，如果是同步 I/O 那么用户线程会等待拷贝的完成，而异步 I/O则这个拷贝过程用户线程该干嘛可以去干吗，当内核拷贝完毕之后会“通知”用户线程。

关于异步的实现方式之一就是多线程，关于线程的创建可以参考 线程创建的过程
所以在使用多线程时通常需要使用线程池，好处：
① 降低资源的消耗，通过重复利用已经创建的线程降低线程创建和销毁造成的消耗。
② 提高相应速度，当任务到达的时候，任务可以不需要等到线程创建就能立刻执行，减少了用户空间栈的创建、减少系统调用(clone等)、用户态内核态切换的过程等
③ 提高线程的可管理性，线程是稀缺资源，使用线程池可以统一的分配、调优和监控。

二、网络I/O

1. BIO

同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理后续的读。即一个线程只能连接一个Socket连接, 处理一个Socket的请求，accept时阻塞等待有客户端连接, read时阻塞等待有数据输入。如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

相关代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketBIO {


    public static void main(String[] args) throws Exception {
        ServerSocket server = new ServerSocket(8090,20);  //netstat -natp   listen socket

        System.out.println("step1: new ServerSocket(8090) ");

        while (true) {
            Socket client = server.accept();  //阻塞1
            System.out.println("step2:client\t" + client.getPort());

            new Thread(new Runnable(){

                public void run() {
                    InputStream in = null;
                    try {
                        in = client.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                        while(true){
                            String dataline = reader.readLine(); //阻塞2

                            if(null != dataline){
                                System.out.println(dataline);
                            }else{
                                client.close();
                                break;
                            }
                        }
                        System.out.println("客户端断开");

                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }



            }).start();

        }
    }


}

在这里插入图片描述
优势：可以接收很多连接

缺点：

  • 线程内存浪费
  • cpu在多个线程之间的切换调度消耗资源

2. NIO

同步非阻塞式IO，一个线程可以连接多个Socket连接，处理多个Socket的请求; 更好的利用了线程, 避免因一个文件阻塞而导致整个线程啥也不干了。
accept时得不到客户端连接 和 read时得不到数据会直接返回默认值负数, 不会在那一直阻塞着等待。

相关代码

import java.net.InetSocketAddress;
import java.net.StandardSocketOptions;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;

public class SocketNIO {
    public static void main(String[] args) throws Exception {

        LinkedList<SocketChannel> clients = new LinkedList<>();

        ServerSocketChannel ss = ServerSocketChannel.open();  //服务端开启监听：接受客户端
        ss.bind(new InetSocketAddress(8090),2);
        ss.configureBlocking(false); //重点  OS  NONBLOCKING!!!  //只让接受客户端  不阻塞
        //  2729 fcntl(4, F_SETFL, O_RDWR|O_NONBLOCK)    = 0

//        ss.setOption(StandardSocketOptions.TCP_NODELAY, false);
//        StandardSocketOptions.TCP_NODELAY
//        StandardSocketOptions.SO_KEEPALIVE
//        StandardSocketOptions.SO_LINGER
//        StandardSocketOptions.SO_RCVBUF
//        StandardSocketOptions.SO_SNDBUF
//        StandardSocketOptions.SO_REUSEADDR




        while (true) {
            //接受客户端的连接
//            Thread.sleep(1000);
            SocketChannel client = ss.accept(); //不会阻塞？  -1 NULL
            //accept  调用内核了：1，没有客户端连接进来，返回值？在BIO 的时候一直卡着，但是在NIO ，不卡着，返回-1，NULL
            //如果来客户端的连接，accept 返回的是这个客户端的fd  5，client  object
            //NONBLOCKING 就是代码能往下走了，只不过有不同的情况

            if (client == null) {
             //   System.out.println("null.....");
            } else {
                client.configureBlocking(false); //重点  socket（服务端的listen socket<连接请求三次握手后，往我这里扔，我去通过accept 得到  连接的socket>，连接socket<连接后的数据读写使用的> ）
                int port = client.socket().getPort();
                System.out.println("client..port: " + port);
                clients.add(client);
            }

            ByteBuffer buffer = ByteBuffer.allocateDirect(4096);  //可以在堆里   堆外

            //遍历已经链接进来的客户端能不能读写数据
            for (SocketChannel c : clients) {   //串行化！！！！  在这里可以使用多线程！！
                int num = c.read(buffer);  // >0  -1  0   //不会阻塞
                if (num > 0) {
                    buffer.flip();
                    byte[] aaa = new byte[buffer.limit()];
                    buffer.get(aaa);

                    String b = new String(aaa);
                    System.out.println(c.socket().getPort() + " : " + b);
                    buffer.clear();
                }


            }
        }
    }

}

在这里插入图片描述
优势：规避了多线程带来的内存&cpu问题
弊端：连接数一多，假如只有一个连接有数据，则在用户空间每遍历一次都要对每个连接发起一次系统调用recv，从用户态切换到内核态，那么其他连接的遍历是无意义的，时间复杂度是O(N)。

3. 多路复用器

同步非阻塞式IO，是对NIO的优化。"多路"是指多个Socket连接, “复用” 指的是复用同一个线程

3.1 select & poll

select其实就是把NIO中用户态要遍历的fd数组(List集合)拷贝到了内核态，并且select能感知到有事件发生, 让内核态来遍历，返回fds的状态，再在用户空间去遍历这些fds，进行相应的操作

select监视的socket默认是1024个，poll没有这个限制而已
在这里插入图片描述
优势：通过一次系统调用，把fds传递给内核，内核进行遍历，减少了系统调用的次数，这里的调用是O(1)的时间复杂度，然后多路复用器返回的是各连接的状态
弊端：

  • 每一次调用select( ), fd数组都会被从用户态拷贝到内核态, 仍具有很大开销
  • select只是感知到了有事件发生, 并没有通知用户态具体是哪一个socket有数据, 返回状态后仍需要O(n)的遍历

3.2 epoll

epoll可以解决上述的两个问题
流程

int s = socket(AF_INET, SOCK_STREAM, 0);   
bind(s, ...)
listen(s, ...)

int epfd = epoll_create(...);
epoll_ctl(epfd, ...); //将所有需要监听的socket添加到epfd中

while(1){
	//检查一下rdllist有没有数据
    int n = epoll_wait(...)
    for(接收到数据的socket){ //这里不是所有socket
        //接收数据处理
    }
}

当某一进程调用epoll_create方法时，Linux内核会创建一个eventpoll结构体，这个结构体中有两个成员与epoll的使用方式密切相关，如下所示：

struct eventpoll {
　　...
　　/*红黑树的根节点，这棵树中存储着所有添加到epoll中的事件，
　　也就是这个epoll监控的事件*/
　　struct rb_root rbr;
　　/*双向链表rdllist保存着将要通过epoll_wait返回给用户的、满足条件的事件*/
　　struct list_head rdllist;
　　...
};

调用epoll_create时，在内核cache里建了个红黑树用于存储以后epoll_ctl传来的socket外，还会再建立一个rdllist双向链表，用于存储准备就绪的事件，当epoll_wait调用时，仅仅观察这个rdllist双向链表里有没有数据即可。有数据就返回，没有数据就sleep，等到timeout时间到后即使链表没数据也返回。所以，epoll_wait非常高效。

所有添加到epoll中的事件都会与设备(如网卡)驱动程序建立回调关系，也就是说相应事件的发生时会调用这里的回调方法。这个回调方法在内核中叫做ep_poll_callback，它会把这样的事件放到上面的rdllist双向链表中。若是多核cpu，这个将对应的fs放入到双向链表中的操作用另一个cpu操作，这样与epoll_ctl或者epoll_wait是并行的。

当调用epoll_wait检查是否有发生事件的连接时，只是检查eventpoll对象中的rdllist双向链表是否有epitem元素而已，如果rdllist链表不为空，则这里的事件复制到用户态内存（使用共享内存提高效率）中，同时将事件数量返回给用户。因此epoll_wait效率非常高。epoll_ctl在向epoll对象中添加、修改、删除事件时，从rbr红黑树中查找事件也非常快，也就是说epoll是非常高效的，它可以轻易地处理百万级别的并发连接。

总结：

  1. 执行epoll_create()时，创建了红黑树和就绪链表；
  2. 执行epoll_ctl()时，如果增加socket句柄，则检查在红黑树中是否存在，存在立即返回，不存在则添加到树干上，然后向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据；
  3. 执行epoll_wait()时立刻返回准备就绪链表里的数据即可。

优势：

  • 只需要把fd数组从用户态拷贝到内核态一次, 而不用每次调用epoll都进行拷贝fd数组
  • 使用事件通知机制, 每次socket中有数据会主动通知内核, 并加入到就绪链表中, 便不需要遍历所有的socket, 而是只遍历就绪列表, 复杂度为O(1)
    在这里插入图片描述

注意：无论是BIO还是NIO还是多路复用器，都是需要程序自己读取数据的，那么这些I/O模型都是同步I/O模型，只不过有阻塞和非阻塞之分，不过像Windows 的 IOCP，内核有线程将数据拷贝到程序的内存空间这就是异步I/O模型。

相关代码

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class SocketMultiplexingSingleThreadv2 {

    private ServerSocketChannel server = null;
    private Selector selector = null;   //linux 多路复用器（select poll epoll） nginx  event{}
    int port = 9090;

    public void initServer() {
        try {
            server = ServerSocketChannel.open();
            server.configureBlocking(false);
            server.bind(new InetSocketAddress(port));
            selector = Selector.open();  //  select  poll  *epoll
            server.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void start() {
        initServer();
        System.out.println("服务器启动了。。。。。");
        try {
            while (true) {
//                Set<SelectionKey> keys = selector.keys();
//                System.out.println(keys.size()+"   size");
                while (selector.select(50) > 0) {
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iter = selectionKeys.iterator();
                    while (iter.hasNext()) {
                        SelectionKey key = iter.next();
                        iter.remove();
                        if (key.isAcceptable()) {
                            acceptHandler(key);
                        } else if (key.isReadable()) {
//                            key.cancel();  //现在多路复用器里把key  cancel了
                            System.out.println("in.....");
                            key.interestOps(key.interestOps() | ~SelectionKey.OP_READ);

                            readHandler(key);//还是阻塞的嘛？ 即便以抛出了线程去读取，但是在时差里，这个key的read事件会被重复触发

                        } else if(key.isWritable()){  //我之前没讲过写的事件！！！！！
                            //写事件<--  send-queue  只要是空的，就一定会给你返回可以写的事件，就会回调我们的写方法
                            //你真的要明白：什么时候写？不是依赖send-queue是不是有空间
                            //1，你准备好要写什么了，这是第一步
                            //2，第二步你才关心send-queue是否有空间
                            //3，so，读 read 一开始就要注册，但是write依赖以上关系，什么时候用什么时候注册
                            //4，如果一开始就注册了write的事件，进入死循环，一直调起！！！
//                            key.cancel();
                            key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);



                            writeHandler(key);
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void writeHandler(SelectionKey key) {
        new Thread(()->{
            System.out.println("write handler...");
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buffer = (ByteBuffer) key.attachment();
            buffer.flip();
            while (buffer.hasRemaining()) {
                try {

                    client.write(buffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buffer.clear();
//            key.cancel();

//            try {
                client.shutdownOutput();
//
                client.close();
//
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
        }).start();

    }

    public void acceptHandler(SelectionKey key) {
        try {
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel client = ssc.accept();
            client.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.allocate(8192);
            client.register(selector, SelectionKey.OP_READ, buffer);
            System.out.println("-------------------------------------------");
            System.out.println("新客户端：" + client.getRemoteAddress());
            System.out.println("-------------------------------------------");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void readHandler(SelectionKey key) {
        new Thread(()->{
            System.out.println("read handler.....");
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buffer = (ByteBuffer) key.attachment();
            buffer.clear();
            int read = 0;
            try {
                while (true) {
                    read = client.read(buffer);
                    System.out.println(Thread.currentThread().getName()+ " " + read);
                    if (read > 0) {
                        key.interestOps(  SelectionKey.OP_READ);

                        client.register(key.selector(),SelectionKey.OP_WRITE,buffer);
                    } else if (read == 0) {

                        break;
                    } else {
                        client.close();
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

    }

    public static void main(String[] args) {
        SocketMultiplexingSingleThreadv2 service = new SocketMultiplexingSingleThreadv2();
        service.start();
    }
}

3.3 Redis的IO多路复用

在这里插入图片描述
用epoll函数来实现IO多路复用, 将连接信息和事件放到队列中, 事件分派器将队列中的事件分发给事件处理器(这一步是单线程的, 所以Redis核心是单线程模型)

Redis基于Reactor模式开发了网络(文件)事件处理器:

  1. 多个Socket套接字连接
  2. IO多路复用器(epoll)
  3. 事件分派器
  4. 事件处理器Handler

具体的redis流程可以看 Redis 究竟是单线程还是多线程呢？

4. Reactor模型

Reactor 模式也叫做反应器设计模式，是一种为处理服务请求并发提交到一个或者多个服务处理器的事件设计模式。当请求抵达后，通过服务处理器将这些请求采用多路分离的方式分发给相应的请求处理器。
在这里插入图片描述
主要有以下三种模型：

  • 单 Reactor 单线程模型
  • 单 Reactor 多线程模型
  • 主从 Reactor 多线程模型
    在这里插入图片描述

具体参考以下文章：
Java IO篇：什么是 Reactor 网络模型？
Reactor 模式

5. Netty

参考：
万字长文带你深入理解netty
Netty实战入门详解

Netty是一款基于NIO（Nonblocking I/O，非阻塞IO）开发的网络通信框架， 对 JDK 自带的 NIO 的 API 进行了封装，像ElasticSearch就是使用了Netty框架。

Netty的线程模型就是类似于主从 Reactor 多线程模型
在这里插入图片描述
1、如何理解NioEventLoop和NioEventLoopGroup
NioEventLoop实际上就是工作线程，可以直接理解为一个线程。NioEventLoopGroup是一个线程池，线程池中的线程就是NioEventLoop。
实际上bossGroup中有多个NioEventLoop线程，每个NioEventLoop绑定一个端口，也就是说，如果程序只需要监听1个端口的话，bossGroup里面只需要有一个NioEventLoop线程就行了。

2、每个NioEventLoop都绑定了一个Selector，所以在Netty的线程模型中，是由多个Selecotr在监听IO就绪事件。而Channel注册到Selector。

3、一个Channel绑定一个NioEventLoop，相当于一个连接绑定一个线程，这个连接所有的ChannelHandler都是在一个线程中执行的，避免了多线程干扰。更重要的是ChannelPipline链表必须严格按照顺序执行的。单线程的设计能够保证ChannelHandler的顺序执行。

4、一个NioEventLoop的selector可以被多个Channel注册，也就是说多个Channel共享一个EventLoop。EventLoop的Selecctor对这些Channel进行检查。

优点：
1、高性能

  • 采用异步非阻塞的IO类库，基于Reactor模式实现，解决了传统同步阻塞IO模式
  • TCP接收和发送缓冲区使用直接内存代替堆内存，避免了内存复制，提升了IO读取和写入的性能，在netty里面通过ByteBuf可以直接对这些数据进行直接操作，从而加快了传输速度
  • 采用环形数组缓冲区实现无锁化并发编程，代替传统的线程安全或锁

2、可靠性

  • 链路有效监测（心跳和空闲检测）
  • 内存保护机制

三、磁盘I/O

参考：Linux 缓存IO、直接IO、内存映射
在这里插入图片描述

磁盘IO延时：

  • 寻道时间：把磁头移动到指定磁道上所经历的时间
  • 旋转延时间：指定扇区移动到磁头下面所经历的时间
  • 传输时间：数据的传输时间（数据读出或写入的时间）

1. 缓存I/O

读操作：
当应用程序调用read()方法时，操作系统检查内核缓冲区是否存在需要的数据，如果存在，那么就直接把内核空间的数据copy到用户空间，供用户的应用程序使用；如果内核缓冲区没有需要的数据，则通过DMA方式从磁盘中读取数据到内核缓冲区（DMA Copy），然后把内核空间的数据copy到用户空间(Cpu Copy)（上图绿色实线部分）

写操作：
当应用程序调用write()方法时，应用程序将数据从用户空间copy到内核空间的缓冲区（如果用户空间没有相应的数据，则需要从磁盘–>内核缓冲区–>用户缓冲区依次读取），这时对用户程序来说写操作就已经完成，至于什么时候把数据再写到磁盘，由操作系统决定。操作系统将要写入磁盘的数据先保存于系统为写缓存分配的内存空间中，当保存到内存池中的数据达到一个程度时，便将数据保存在硬盘中。这样可以减少实际的磁盘操作，有效的保护磁盘免于重复的读写操作而导致的损坏，也能减少写入所需的时间。除非应用程序显式的调用了sync命令，立即把数据写入磁盘。
如果应用程序没准备好写的数据，则必须先从磁盘读取数据才能执行写操作，这时会涉及到四次缓冲区的copy：
a、第一次从磁盘的缓冲区读取数据到内核缓冲区（DMA Copy）；
b、第二次从内核缓冲区复制到用户缓冲区（Cpu Copy）；
c、第三次从用户缓冲区写到内核缓冲区（Cpu Copy）；
d、第四次从内核缓冲区写到磁盘（DMA Copy）；（上图绿色实线部分双向箭头）

缓存I/O的缺点：在缓存I/O机制中，DMA方式可以将数据直接从磁盘读到页缓存中，或者将数据从页缓存直接写回到磁盘上，而不能直接在应用程序地址空间和磁盘之间进行数据传输。这样的话，数据 在传输过程中需要在应用程序地址空间和页缓存之间进行多次数据拷贝操作，这些数据拷贝操作所带来的CPU以及内存开销是非常大的。对于某些特殊的应用程序来说，避开操作系统内核缓冲区，而直接在应用程序地址空间和磁盘之间传输数据，会比使用操作系统内核缓冲区获取更好的性能，因此引入"Direct I/O"。

2. Direct I/O

凡是通过直接 I/O 方式进行数据传输，数据均直接在用户地址空间的缓冲区和磁盘之间直接进行传输，完全不需要页缓存的支持。Direct I/O 本质是 DMA 设备把数据从用户空间拷贝到设备,或是从设备拷贝到用户空间。

进程在打开文件的时候设置对文件的访问模式为 O_DIRECT ，这样就等于告诉操作系统进程在接下来使用 read() 或者 write() 系统调用去读写文件的时候使用的是直接 I/O 方式，所传输的数据均不经过操作系统内核缓存空间。

直接I/O优点：

  • 数据直接缓存在应用层，应用能够更加灵活的操作数据
  • 减少操作系统缓冲区和用户地址空间的拷贝次数
  • 降低CPU开销和内存带宽

直接I/O缺点：

  • 直接 I/O 的开销也很大，如果访问的数据不在应用程序缓存中，因为系统基本不缓存数据，那么每次数据都会直接从磁盘加载
  • 磁盘的读写是通过磁头的切换到不同的磁道上读取和写入数据，如果需要写入数据在磁盘位置相隔比较远，就会导致寻道的时间大大增加，写入读取的效率大大降低。
  • O_DIRECT也不能确保数据每次写入的时候同步写入磁盘，因此如果需要数据同步写入磁盘还需要手工设置O_SYNC标识或者手工调用fsync方法

通常直接IO与异步IO结合使用，会得到比较好的性能。

3. mmap

mmap 本质是内存共享机制，它把 page cache 地址空间映射到用户空间，换句话说，mmap 是一种特殊的 Buffered I/O，这种方式的目的同样是减少数据在用户空间和内核空间之间的拷贝操作，当大量数据需要传输的时候，采用内存映射方式去访问文件会获得比较好的效率。

在这里插入图片描述
mmap 内存映射过程：

  • 进程在虚拟地址空间中为映射创建虚拟映射区域
  • 内核把文件物理地址和进程虚拟地址进行映射
  • 进程发起对这片映射空间的访问，引发缺页异常，实现文件内容到物理内存（主存）的拷贝
    换句话说，在调用 mmap 后，只是在进程的虚拟空间中分配了一段空间，真实的物理地址还不会分配的。
  • 当进程第一次访问这段空间（当作内存一样），CPU 陷入 OS 内核执行异常处理。然后异常处理会在这个时间分配物理内存，并用文件的内容填充这片内存，然后才返回进程的上下文，这时进程才会感知到这片内存里有数据

在这里插入图片描述

4. write、flush、fsync

参考：Linux I/O操作fsync后数据就安全了么(fsync、fwrite、fflush、mmap、write barriers详解)
在这里插入图片描述

Cool_Pepsi
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅析标准I/O缓冲区
01-19
　学习过编程的朋友都知道ANSI C里定义的标准I/O是一种带缓冲的磁盘I/O，目的是尽可能减少使用read和write系统调用的次数，从而提高I/O效率。标准I/O提供了3种类型的缓冲类型。 　● 全缓冲。在这种情况下，当填满...
使用并发I/O改进DB2数据库性能
03-02
并发I/O和缓存I/O是两个与文件系统相关联的功能。出于此原因，大部分DB2DBA认为这两种技术的使用取决于存储和系统管理员的见识。然而，在DB2数据库环境中利用此技术是DBA的职责。事实上，IBM的DB2专家推荐在数据库...
5种IO模型
qq_50313695的博客
10-17 1286
5中IO操作
网络IO与磁盘IO
w7486的博客
12-22 1818
Java中的IO体系:在Java中I/0流操作的类很多，但是核心体系实际上就只有File、lnputStream、OutputStream、Reader、Writer. IO流的分类: IO流的数据来源 1.网络 2.磁盘 //磁盘 FileInputStream fi = null; //创建管道 try { fi = new FileInputStream("d:/111/123.txt"); //存放在磁盘..
从磁盘看 IO
weixin_70280523的博客
06-30 1504
磁盘IO
网络io，磁盘io,线程池解决思想
weixin_57711380的博客
06-21 1543
网络io，磁盘io一些知识点。
同步、异步、阻塞、非阻塞、并发、并行在网络IO、磁盘IO中的具体概念
qq_36454352的博客
08-23 1088
同步、异步、阻塞、非阻塞、并发、并行
Zabbix动态监控磁盘I/O
04-23
《Zabbix动态监控磁盘I/O详解》 在IT运维管理中，监控系统性能是至关重要的环节，其中磁盘I/O（输入/输出）监控尤为关键，因为它是衡量系统响应速度和数据处理能力的重要指标。Zabbix作为一个强大的开源监控解决...
I/O交互支持库
07-24
在IT领域，I/O交互支持库扮演着至关重要的角色，它是连接应用程序与操作系统之间进行数据交换的桥梁。I/O（Input/Output）交互是计算机系统中必不可少的部分，无论是读取用户输入、写入文件，还是与其他设备通信，都...
LabVIEW的文件I/O
01-19
在LabVIEW程序设计中，常常需要调用外部文件数据，同时也需要将程序产生的结果数据保存至外部文件中，这些都离不开文件I/O操作。文件IiO操作是LabVIEW和外部交换数据的重要方式。 　文件I/O的基本概念和术语 　在...
Linux系统设计-linux 系统资源监控库，监控进程占用的CPU、内存、磁盘IO、网络IO
最新发布
01-10
所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！Linux系统是一个免费使用和自由传播的类Unix操作系统，基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统，Linux是许多企业和服务提供商的首选操作系统，用于部署Web服务器、数据库服务器、邮件服务器等。Linux系统具有高效的网络功能和稳定的性能，因此被广泛应用于服务器领域，Linux是云计算的核心组成部分，被广泛用于构建云平台和云服务。许多知名的云计算服务提供商都采用Linux系统作为其基础架构，一些游戏平台和游戏开发工具采用Linux作为支持的操作系统，例如Steam平台上的某些游戏。Linux系统在科学计算、数据分析和机器学习等领域也有广泛应用。许多知名的科学计算软件都在Linux上开发和运行，Linux系统在各个领域都有广泛的应用，其强大的功能和灵活性使得它成为许多产品和服务的基础架构。
服务器磁盘IO是什么意思？SATA和固态硬盘的性能差异
携手驰网多多一同探索拥有一台服务器可以做哪些很酷的事情吧~
08-01 348
如果读写速度快，也即硬盘IO的性能高。当然影响读写速度的因素有很多，硬盘的性能优化技巧也是一门大学问，但是我们自己在选择硬盘的时候只要了解一点就可以知道硬盘IO的性能了，那就是价格。首先，硬盘的数据存储在硬盘驱动器内各个扇区上，扇区是以一定的磁密度为间隔划分出来的磁盘区域。SSD也称固态硬盘，具有读写速度快、存取时间短，低功耗、无噪音、抗震动、低热量 、体积小、工作温度范围大的优点，相比之下其成本也会稍高。SATA，机械式硬盘，具有较快的传输速率和较大的存储空间，适用于普通用户，价格上也较有优势。
磁盘IO 基本常识
程序猿进阶
04-22 5483
计算机硬件性能在过去十年间的发展普遍遵循摩尔定律，通用计算机的 CPU主频早已超过3GHz，内存也进入了普及DDR4的时代。然而传统硬盘虽然在存储容量上增长迅速，但是在读写性能上并无明显提升，同时SSD（固态硬盘）硬盘价格高昂，不能在短时间内完全替代传统硬盘。传统磁盘的 I/O读写速度成为了计算机系统性能提高的瓶颈，制约了计算机整体性能的发展。 硬盘性能的制约因素是什么？如何根据磁盘I/O特性来进行系统设计？针对这些问题，本文将介绍硬盘的物理结构和性能指标，以及操作系统针对磁盘性能所做的优化，最后讨论下
深入理解Linux内核-磁盘IO-虚拟文件系统
x13262608581的博客
08-12 700
深入理解Linux内核--虚拟文件系统
Linux磁盘IO详解及常用命令介绍
fastboot
12-19 1043
在Linux系统中，磁盘IO是一种关键的性能因素，它影响着系统的响应速度和数据处理能力。本文将详细介绍Linux磁盘IO的概念、性能指标以及机械硬盘和SSD硬盘的IO差异。一、Linux磁盘IO概述Linux磁盘IO是通过文件系统来执行的，每个文件都被映射为一个文件描述符，通过这个描述符可以执行读写操作。磁盘IO的性能受到硬件性能、系统配置、应用程序等多种因素的影响。二、Linux磁盘IO性能指标...
说说 IO流 及 Socket编程
CaBCo的博客
08-26 895
一、IO 流的分类 IO流可以操作磁盘数据文件的读写，读写处理效率的高低直接影响到服务响应请求的性能。 IO分为BIO (Blocking I/O)，NIO（New I/O）, AIO（Asynchronous I/O） BIO：同步阻塞I/O模式，数据的读取及写入阻塞在一个线程内等待其完成，一请求一应答 NIO：同步非阻塞I/O模式，包含以下几个核心组件： Channel(通道) Buffer(缓冲区) Selector(选择器) AIO：也即NIO2，异步非阻塞I/O模式，尚未广泛应用
【操作系统】磁盘IO常见性能指标和分析工具实战
互联网小阿祥
02-14 6068
磁盘IO常见性能指标和分析工具实战
深入理解Linux内核-磁盘IO-I/0体系结构和设备驱动程序
x13262608581的博客
08-15 1077
I/0体系结构和设备驱动程序
磁盘及网络IO工作方式解析
weixin_34284188的博客
12-04 841
PIO与DMA 有必要简单地说说慢速I/O设备和内存之间的数据传输方式。 PIO我们拿磁盘来说，很早以前，磁盘和内存之间的数据传输是需要CPU控制的，也就是说如果我们读取磁盘文件到内存中，数据要经过CPU存储转发，这种方式称为PIO。显然这种方式非常不合理，需要占用大量的CPU时间来读取文件，造成文件访问时系统几乎停止响应。 DMA后来...
第8章 输入输出系统.ppt1
08-03
【资源摘要信息】: "本资源为《第8章 输入输出系统》的PPT讲义，主要涵盖了磁盘存储器和I/O接口的相关知识，包括I/O系统的性能、功能、操作系统在I/O系统中的作用，以及I/O设备的通用模型、磁盘存储器的工作原理、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值