Nettey之IO介绍

IO

BIO（阻塞）

public class SocketBIO {
    public static void main(String[] args) throws IOException {
        //缓存队列20
        ServerSocket server = new ServerSocket(9090,20);

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

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

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

                            if (dataline != null) {
                                System.out.println(dataline);
                            }else{
                                client.close();
                                break;
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

特点:

1. 是一种阻塞（block）的io

2. 每个线程对应每一个连接

3. 线程太多，资源消耗大，系统调度多

   系统调度多代表着用户态转换成内核态的过程很频繁

   这个过程消耗时间的有：保护现场，恢复现场，发生软中断，寻找中断向量表，系统回调函数

JDK1.8以后加了多路复用器实现

NIO（非阻塞）

内核自带的功能

public class SocketNIO {
    public static void main(String[] args) throws Exception {
        //SocketChannel套接字通道,支持非阻塞
        LinkedList<SocketChannel> clients = new LinkedList<>();

        //ServerSocketChannel面向流的侦听套接字
        ServerSocketChannel ss = ServerSocketChannel.open();    //服务端开启监听:接收客户端
        ss.bind(new InetSocketAddress(9090));
        ss.configureBlocking(false);    //调用了 OS  NONBLACKING!!!    //只让接受客户端  不阻塞



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

            if (client == null) {
                System.out.println("null....");
            }else{
                client.configureBlocking(false);//  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();
                }
            }
        }
    }
}

把阻塞变为非阻塞，就意味着无论什么情况（有没有连接，有没有接收到信息），代码都要继续执行下去，这样的话，可以把方法设置有返回值，返回的就是面临的三种状态：

1、有连接、有数据传输，那就直接输出，返回一个文件描述符5

2、没有连接、没有数据，返回0（状态码）

3、客户端关闭连接，返回-1（状态码）

总结就是，调用内核的NONBLOCK要么返回，要么返回-1

特点：只需要一个线程就可以处理N个连接以及读写

但是NIO有一个很严重的弊端：无限的系统调用，频繁的用户态和内核态切换（代表程序性能不高）

假设上面的clients集合里有一万个客户端，但是只有一个有数据，语句循环了一万次，进行了一万次accept和read的系统调用，但是只有最后一个才是有数据的，应该要有数据时才调用read才对

多路复用器

目的：为了将O（n）降为O（m）

有同步模型和异步模型

这里只说同步的：select、poll、epoll（Linux的）

这里先假设一个场景：

一个汽车收费站，在BIO的时候，每一条路都是一个线程处理

NIO的时候，节省资源，每一条路都是这个线程去问，看看有没有人进来，这时候就会很累

采用多路复用器

建一个电话，假设当有人来了（客户端发数据），打电话通知一声，叫app去处理1、2、3、4路的任务，有通知了，才会去处理，即有数据传输了才去处理这个客户端，但是这个处理读取数据还是线程自己去处理的（内核自己去read），这种要自己去read的就叫同步IO。

这个电话就是多路复用器，select、poll早先的时候是这两个，执行的时候返回状态集（？文件描述符）（查看这个多路复用器的Linux 指令 man 2 select）

注意：操作系统里NIO(NONBLACK IO)和多路复用器关系不大，都是独立的一个东西，而Java里的NEW IO（NIO）有内核的NONBLACK也用到了多路复用器

弊端（select、poll）：

1.每次重复传输数据（因为select的内核不会存储数据）

2.每次调用要触发内核遍历（先切换到用户态去读取文件描述符，然后再去内核态调用read，一直重复直到没有事件处理为止）

epoll

为了解决内核重复传输，读取数据，继续上面的模拟场景

建立一个像电话本一样的东西（使用epoll会在内核里开辟一个空间），记下每个收费通道的位置信息

假如client来了数据cup1会中断cpu0（cpu0和cpu1可以同步或者异步），开始三次握手接收数据，然后把连接的文件描述符放进在内核中开辟cteate一个空间里，在生命周期中只会添加一次，把这个连接的文件描述符放里面，当cup0想去了解具体是哪个client来数据了要处理，就去打一个电话（即使用wait方法），取回一个结果集得到需要处理的文件描述符（在自己内存中,为什么不自己去拿AIO？）

epoll中有三种方法：

1. create开辟空间
2. ctl
   • ctl_add添加
   • ctl_mo修改
   • ctl_de删除
3. wait获取结果集