IO学习笔记(1)

已于 2022-05-19 17:56:41 修改
阅读量275 收藏
点赞数
文章标签： 学习 linux 网络 java
于 2022-05-19 15:07:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xsqxsqx/article/details/124860102
版权

笔记整理

前置知识

1、系统调用 我们的硬件都是交给操作系统的kernel（内核，c/c++写的）管理，当我们的程序想要获取硬件的数据时（如网卡缓冲区的数据），由于保护模式，程序是不能直接读取硬件数据，需要调用kernel的代码去读取，这个过程就是系统调用。
系统调用是比较耗cpu性能的，因为这个过程需要保护现场，恢复现场，系统态内核态的切换等等。

2、创建一个soket连接必经的三步：（linux socket编程-socket接口详细连接地址）

  • 调用 int socket(int domain, int type, int protocol);这个函数建立一个协议族为domain、协议类型为type、协议编号为protocol的套接字文件描述符。
  • 调用int bind( int sockfd, struct sockaddr* addr, socklen_t addrlen);在进行网络通信的时候，必须把一个套接字与一个地址相关联。
  • 调用int listen(int sockfd, int backlog); 监听。

传统BIO

传统的bio就是我们写烂了的那个代码，如下：

public class Server {
    public static void main(String[] args) {
        try {
            // 1.注册端口
            ServerSocket ss = new ServerSocket(9999);
            // 2.定义一个循环接收客户端的Socket连接请求
            // 初始化一个线程池对象
            SocketServerPoolHandler poolHandler = new SocketServerPoolHandler(3, 10);
            while (true) {
                Socket socket = ss.accept();
                // 3.把Socket对象交给一个线程池进行处理
                // 把Socket封装成一个任务对象交给线程池处理，ServerRunnableTarget的具体代码就不给出了哈。
                Runnable target = new ServerRunnableTarget(socket);
                poolHandler.execute(target);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

因为accept()会阻塞，read()也会阻塞，所以不要把两个放到一个线程里。
这样其实没什么问题的，如果连接数比较小这样的性能也不错，但由于是一个线程一个请求，请求数一多就会造成C10K问题。
tips: 为什么accept()会阻塞，read()也会阻塞？
因为这两个函数实际上会调用操作系统kernel的accept()、recv(),也就是会发生系统调用。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
/*参数说明
sockfd是由socket函数返回的套接字描述符，
addr和addrlen用来返回已连接的对端进程（客户端）的协议地址。
如果我们对客户端的协议地址不感兴趣，可以把arrd和addrlen均置为空指针
*/
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
/*sockfd ：套接字
buf : 待发送或者接收的缓存
len : 如果是recv指期望接收的长度，如果是send指要发送的长度。
flags : 标志位*/

在操作系统中这两个函数就会阻塞，所以accept()会阻塞，read()也会阻塞。

NIO（无多路复用器版）

于是就有了对bio的改进—nio（在java里指new io,操作系统指nonBlocking io）。
nio就是用一个线程管理多个连接（注意这里可以一个线程管理多个连接是因为操作系统的accept()、recv()修改了，没有连接、数据就返回-1，不会阻塞了)。如果没有操作系统的提升就不能一个线程管理多个连接，不然会堵车，一个阻塞了后面所有都阻塞，因为只有一个线程嘛。代码如下：

public class SocketNIO {
    public static void main(String[] args) throws Exception {
        LinkedList<SocketChannel> clients = new LinkedList<>();//保存soket连接的channel
        ServerSocketChannel ss = ServerSocketChannel.open();  //服务端开启监听：接受客户端
        ss.bind(new InetSocketAddress(9090));
        ss.configureBlocking(false); //不阻塞

        while (true) {
            //接受客户端的连接
            SocketChannel client = ss.accept(); //不会阻塞  -1 NULL
            //accept  调用内核了：1，没有客户端连接进来， 在BIO 的时候一直卡着，但是在NIO ，不卡着，返回-1(内核层面)，null（java层面）
            if (client == null) {
             //   System.out.println("null.....");//没有客户端连接
            } else {
                client.configureBlocking(false); //得到连接同样设置为非阻塞
                int port = client.socket().getPort();
                System.out.println("client..port: " + port);
                clients.add(client);//将得到的连接添加到LinkedList<SocketChannel> clients
            }

            ByteBuffer buffer = ByteBuffer.allocateDirect(4096);  //得到一个缓冲区buffer可以在堆里、外
            //**遍历已经链接进来的客户端能不能读写数据**
            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();
                }


            }
        }
    }

}

tips:因为操作系统做了升级，accept()、recv()不会阻塞了，那么就不用向以前那样一个线程一个连接了，可以用一个线程管理多个连接，但是这样还是有弊端：

  • 在“遍历已经链接进来的客户端能不能读写数据”这块代码里，如果已经链接进来的客户端很多，那么这块代码就会执行很久，这个过程中将不能接受新的连接。其实这个很好解决，我们可以专门开一个线程处理这块代码。
  • 这种写法最大的性能损耗不是循环次数太多，而是太多系统调用，太多用户态和内核态的切换！我们的read(buffer)函数虽然不会阻塞，但是还是需要调用内核的recv()函数，这就会产生大量的系统调用，而且可能还是大量无意义的系统调用（假设1万个链接，有可能只有一个链接有数据，那9999次都是无用的系统调用）。

NIO（多路复用器版，select、poll、epoll）

前面说了假设1万个链接，有可能只有一个链接有数据，那9999次都是无用的系统调用，那可不可以某一个函数主动告诉我哪些soket有数据，然后我只遍历这些有数据的就好啦？当然可以，这就是epoll()函数，也是最终的纠结方案，但其实在此之前还经历了几次演变select->poll->epoll。
（1）select、poll 都是调用 client.register()方法在jvm里开辟一个数组将所有soket连接的文件描述符（fd）放进去，可以通过selector.select()方法通过一次系统调用将所有文件描述符传给内核，让内核帮我们循环，返回有事件的文件描述符集合！ 可以看到这里还是要循环，只是内核帮我们做了，这样减少了系统调用的次数，仅仅有一次系统调用，这就是IO多路复用！

（2）epoll在java层面的代码和前面两个一样，只是不会在jvm里开辟一个数组将所有soket连接的文件描述符（fd）放进去，而是会在内核开辟空间存。client.register()会调用内核的epoll_ctl(fd3,ADD,fd7,EPOLLIN，，将文件描述法添加到内核空间，当有事件时内核会帮我们把所有有事件的文件描述符放到一起返回给我们，这样只有在创建连接的时候会发生一次系统调用，内核也不会每次循环了，效率再次提升。
代码如下：

public class SocketMultiplexingSingleThreadv1 {
    //注意！！！！！！！！！！！
    //java 使用多路复用器  ，多路复用器其实是kernel提供的，种类很多，java的selector包装了这些东东
    //具体用哪一个就看你的操作系统有哪个了，一般有epoll就用epoll
    private ServerSocketChannel server = null;
    private Selector selector = null;   //linux 多路复用器（select poll    epoll kqueue） nginx  event{}
    int port = 9090;
    public void initServer() {
        try {
            server = ServerSocketChannel.open();
            server.configureBlocking(false);
            server.bind(new InetSocketAddress(port));
            //如果在epoll模型下，open--》  epoll_create -> fd3
            selector = Selector.open();  //  select  poll  |   *epoll  优先选择：epoll  但是可以 -D修正

            //内核 epoll 开辟空间  select poll 不开辟空间
            //c语言实现jvm  J空间
            //java代码 空间

            //  selector ?  select ?  poll   ?  epoll ?




            //server 约等于 listen状态的 fd4
            /*
            register
            如果：
            select，poll：jvm里开辟一个数组 fd4 放进去
            epoll：  epoll_ctl(fd3,ADD,fd4,EPOLLIN
             */
            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");


                //1,调用多路复用器(select,poll  or  epoll  (epoll_wait))
                /*
                select()是啥意思：
                1，select，poll  其实  内核的select（fd4）  poll(fd4)
                2，epoll：  其实 内核的 epoll_wait()
                *, 参数可以带时间：没有时间，0  ：  阻塞，有时间设置一个超时
                selector.wakeup()  结果返回0

                懒加载：
                其实再触碰到selector.select()调用的时候触发了epoll_ctl的调用


                 */

                //完成了  内核到  jvm  空间的一个事件的拷贝
                while (selector.select() > 0) {
                    //是从jvm空间把 有时间的集合拷贝到java程序猿手里~！！！！！！！！
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();  //返回的有状态的fd集合
                    Iterator<SelectionKey> iter = selectionKeys.iterator();
                    //so，管你啥多路复用器，你呀只能给我状态，我还得一个一个的去处理他们的R/W。同步好辛苦！！！！！！！！
                    //  NIO  自己对着每一个fd调用系统调用，浪费资源，那么你看，这里是不是调用了一次select方法，知道具体的那些可以R/W了？
                    //幕兰，是不是很省力？
                    //我前边可以强调过，socket：  listen   通信 R/W
                    while (iter.hasNext()) {
                        SelectionKey key = iter.next();
                        iter.remove(); //set  不移除会重复循环处理
                        if (key.isAcceptable()) {
                            //看代码的时候，这里是重点，如果要去接受一个新的连接
                            //语义上，accept接受连接且返回新连接的FD对吧？
                            //那新的FD怎么办？
                            //select，poll，因为他们内核没有空间，那么在jvm中保存和前边的fd4那个listen的一起
                            //epoll： 我们希望通过epoll_ctl把新的客户端fd注册到内核空间
                            acceptHandler(key);
                        } else if (key.isReadable()) {
                            readHandler(key);  //连read 还有 write都处理了
                            //在当前线程，这个方法可能会阻塞  ，如果阻塞了十年，其他的IO早就没电了。。。
                            //所以，为什么提出了 IO THREADS
                            //redis  是不是用了epoll，redis是不是有个io threads的概念 ，redis是不是单线程的
                            //tomcat 8,9  异步的处理方式  IO  和   处理上  解耦
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void acceptHandler(SelectionKey key) {
        try {
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel client = ssc.accept(); //来啦，目的是调用accept接受客户端  fd7
            client.configureBlocking(false);

            ByteBuffer buffer = ByteBuffer.allocate(8192);  //前边讲过了

            // 0.0  我类个去
            //你看，调用了register
            /*
            select，poll：jvm里开辟一个数组 fd7 放进去
            epoll：  epoll_ctl(fd3,ADD,fd7,EPOLLIN
             */
            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) {
        SocketChannel client = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear();
        int read = 0;
        try {
            while (true) {
                read = client.read(buffer);
                if (read > 0) {
                    buffer.flip();
                    while (buffer.hasRemaining()) {
                        client.write(buffer);
                    }
                    buffer.clear();
                } else if (read == 0) {
                    break;
                } else {
                    client.close();
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();

        }
    }

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

tips:正如前面所言在java层面select、poll、epoll的代码是一样的，只是会调用不同的内核函数。
selector = Selector.open() 开辟一个空间用于存放文件描述符fd。select、poll会在jvm生成，epoll会调用OS kernel的 epoll_creat()函数，在内核开辟。
SocketChannel.register() 就是将文件描述符注册到开辟的空间里。
selector.select() 就是将jvm中的文件描述符通过一次系统调用传给内核让其帮我们循环返回有事件的fds(select、poll)或直接返回有事件的fds(epoll，调用的是epoll_wait());

当然selector不是只能有一个，完全可以用多个来进一步提高效率，这就像netty里的boss和worker。

其实io模型的升级依赖于内核的升级，如果内核不能非阻塞，不能帮我们做循环、不能基于事件通知就不会有nio了，那具体内核是如何实现这些功能的还得去看kernel的c/c++源码！！

长发无非遮丑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FREEROTS学习笔记（1）
weixin_51626643的博客
03-29 151
FREEROTS学习笔记（1） 学习目标：简单学习freertos的运作规律 学习前知道的内容 1、任务——“运行中的函数” 2、能够运行的函数才叫“任务” FREERTOS和普通单片机的区别 1、单片机：在运行某个任务后才会再次执行下次任务 freertos：在执行某个任务时会暂停去运行其他任务，如何如此操作，直至任务完成 学习时间： 提示：这里可以添加计划学习的时间 例如： 周一至周五晚上 7 点—晚上9点 周六上午 9 点-上午 11 点 周日下午 3 点-下午 6 点 学
文件IO学习笔记
09-12
本篇学习笔记将深入探讨文件I/O的基本概念、常见API、操作模式以及一些实用技巧，旨在帮助初学者快速入门。 首先，我们来了解一下什么是文件I/O。在计算机系统中，文件I/O是指应用程序通过操作系统提供的接口，与...
【Java并发编程】Java多线程（五）：关于线程的几个问题
A minor
09-16 1612
1.子线程 1 去等待子线程 2 执行完成之后才能执行，如何去实现？ 答：这里考察的就是 Thread.join 方法，我们可以这么做： @Test public void testJoin2() throws Exception { // 线程2 Thread thread2 = new Thread(new Runnable() { public void run() {...} }); // 线程1 Thread thread1 = new Thread(new Runna
多路复用器底层原理
Ives_WangShen的博客
09-12 910
NIO、多路复用底层原理 .
io流学习笔记is
weixin_52536378的博客
12-14 319
代码前面加一个@Test引入一下。
IO多路复用学习笔记
qq_23095607的博客
05-27 279
参考笔记。
java IO流学习笔记
12-12
java IO流学习笔记
java io流学习笔记1
04-18
Java IO流是Java编程语言中处理输入...通过深入学习和理解IO流，开发者可以更好地掌握数据的读取、写入和传输，提升程序的效率和功能。同时，熟悉相关工具和配置文件的使用也能帮助开发者在实际项目中更加得心应手。
io学习笔记
12-02
包括io的学习的所有的笔记，整理的相当好
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
Lumos学习王佩丰Excel第四讲：排序与选择
Sunshine_XX的博客
07-10 320
自定义排序演示：工资条拆分的演示：如果遇到很长的表，标题只存在于顶端，打印出来观感不好，可以这样做：有些版本的excel复制筛选数据容易把背后隐藏的所有数据都复制上去，这时可选中定位条件的“可见单元格”选项，复制粘贴即可。并排表示且，错排表示或。ctrl+shift+↓+→全选，演示说明：回头学原理，先记住一句话，要想筛选对，条件表头不要对。
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 675
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
周陽讀書
07-11 738
ROS运行管理。
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 622
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 674
Qt/QML学习-动画元素
昇思MindSpore 25天学习打卡营|day20
最新发布
weixin_42036358的博客
07-13 519
生成式对抗网络(Generative Adversarial Networks，GAN)是一种生成式机器学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。最初，GAN由Ian J. Goodfellow于2014年发明，并在论文生成器的任务是生成看起来像训练图像的“假”图像；判别器需要判断从生成器输出的图像是真实的训练图像还是虚假的图像。GAN通过设计生成模型和判别模型这两个模块，使其互相博弈学习产生了相当好的输出。GAN模型的核心在于提出了通过对抗过程来估计生成模型这一全新框架。
学懂C#编程：常用框架学习（二）——初学者如何学习WPF之MVVM模式
martian665的专栏
07-10 535
初学者如何学习WPF之MVVM模式
NPDP含金量高吗？什么人适合学习NPDP？
PMP项目管理的博客
07-09 928
开始报名后先提交报名资料，通过审核后缴纳考试费用，即算报名成功；如果报名成功后被抽中审核了的话，则须提交相关资料进行资格审查，通过审查即可参加考试，未通过审核则会将考试费用退还给您；
昇思25天学习打卡营第19天|ShuffleNet图像分类
randomize0的专栏
07-12 947
在第15-18日的学习内容中，我们陆陆续续学习了计算机视觉相关的模型包括图像语义分割、图像分类、目标检测等内容，这些模型的运算往往都是在大算力设备上运行的，今天学习一种可以在移动设备上运行的图像分类模型-“ShuffleNet”。ShuffleNetV1是旷视科技提出的一种计算高效的CNN模型，和MobileNet, SqueezeNet等一样主要应用在移动端，所以模型的设计目标就是利用有限的计算资源来达到最好的模型精度。
黑马程序员io流笔记
07-29
根据提供的引用内容，IO流是Java中用于处理输入和输出的机制。在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等二进制对象时更常用，而字符流在处理中文时更为方便。\[1\]\[2\]无论是使用字节流还是字符流，操作文件时都需要使用File类来定位文件对象，并通过字节流或字符流的子类来创建对象进行读写操作。最后，需要关闭输入/输出流以释放资源。\[3\] 关于黑马程序员的IO流笔记，根据提供的信息，无法得知具体内容。请提供更多细节或具体问题，以便我能够给出更准确的回答。 #### 引用[.reference_title] - *1* *2* *3* [黑马程序员—IO学习笔记](https://blog.csdn.net/showingtime/article/details/45305741)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值