9.0.网络编程_IO 通信模型

5. IO 通信模型

　　网络通信的本质是网络间的数据 IO。只要有 IO，就会有阻塞或非阻塞的问题，无论这个 IO 是网络的，还是硬盘的。原因在于程序是运行在系统之上的，

任何形式的 IO 操作发起都需要系统的支持

　　使用套接字建立TCP连接后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接到服务器端的输入流，而客

户端的输入流连接到服务器端的输出流

5.1. BIO（阻塞模式）

　　BIO 即 blocking IO,是一种阻塞式的 IO；jdk1.4 版本之前 Socket 即 BIO 模式；BIO 的问题在于 accept()、read()的操作点都是被阻塞的

　　服务器线程发起一个 accept 动作（侦听并接受到此套接字的连接），询问操作系统是否有新的 socket 信息从端口 X 发送过来。注意，是询问操作系

统；如果操作系统没有发现有 socket从指定的端口 X 来，那么操作系统就会等待。这样serverSocket.accept()方法就会一直等待。这就是为什么 accept()方

法为什么会阻塞

　　如果想让 BIO 同时处理多个客户端请求，就必须使用多线程，即每次 accept阻塞等待来自客户端请求，一旦收到连接请求就建立通信，同时开启一个新

的线程来处理这个套接字的数据读写请求，然后立刻又继续 accept 等待其他客户端连接请求，即为每一个客户端连接请求都创建一个线程来单独处理

传统socket代码：客户端

import java.io.DataOutputStream;

import java.io.FileInputStream;

import java.net.Socket;

public class TraditionalClient {

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

        long start = System.currentTimeMillis();

        // 创建socket链接

        Socket socket = new Socket("localhost", 2000);

        System.out.println("Connected with server： " + socket.getInetAddress() + ":" + socket.getPort());

        // 读取文件

        FileInputStream inputStream = new FileInputStream("C:/sss.txt");

        // 输出文件

        DataOutputStream output = new DataOutputStream(socket.getOutputStream());

        // 缓冲区4096K

        byte[] b = new byte[4096];

        // 传输长度

        long read = 0, total = 0;

        // 读取文件，写到socketio中

        while ((read = inputStream.read(b)) >= 0) {

            total = total + read;

            output.write(b);

        }

        // 关闭

        output.close();

        socket.close();

        inputStream.close();

        // 打印时间

        System.out.println("bytes send--" + total + " and totaltime--" + (System.currentTimeMillis() - start));

    }

}

传统socket代码：服务端

package cn.itcast_02_nio;

import java.io.DataInputStream;

import java.net.ServerSocket;

import java.net.Socket;

public class TraditionalServer {

    @SuppressWarnings("resource")

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

        // 监听端口

        ServerSocket server_socket = new ServerSocket(2000);

        System.out.println("等待，端口为：" + server_socket.getLocalPort());

        while (true) {

            // 阻塞接受消息

            Socket socket = server_socket.accept();

            // 打印链接信息

            System.out.println("新连接： " + socket.getInetAddress() + ":" + socket.getPort());

            // 从socket中获取流

            DataInputStream input = new DataInputStream(socket.getInputStream());

            // 接收数据

            byte[] byteArray = new byte[4096];

            while (true) {

                int nread = input.read(byteArray, 0, 4096);

                System.out.println(new String(byteArray, "UTF-8"));

                if (-1 == nread) {

                    break;

                }

            }

            socket.close();

            System.out.println("Connection closed by client");

        }

    }

}

5.2.NIO（非阻塞模式）

　　NIO 即 non-blocking IO,是一种非阻塞式的 IO。jdk1.4 之后提供

　　NIO 三大核心部分：Channel(通道)，Buffer(缓冲区), Selector（选择器）

　　Buffer：容器对象，包含一些要写入或者读出的数据。在 NIO 库，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；

在写入数据时，也是写入到缓冲区中。任何时候访问 NIO 中的数据，都是通过缓冲区进行操作

　　Channel：通道对象，对数据的读取和写入要通过 Channel，它就像水管一样。通道不同于流的地方就是通道是双向的，可以用于读、写和同

时读写操作。Channel 不会直接处理字节数据，而是通过 Buffer 对象来处理数据

　　Selector：多路复用器，选择器。提供选择已经就绪的任务的能力。Selector会不断轮询注册在其上的 Channel，如果某个 Channel 上面发生

读或者写事件，这个 Channel 就处于就绪状态，会被 Selector 轮询出来，进行后续的 I/O 操作。这样服务器只需要一两个线程就可以进行多客户端

通信

Socket Nio代码：客户端

import java.io.FileInputStream;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.SocketAddress;

import java.nio.channels.FileChannel;

import java.nio.channels.SocketChannel;

public class TransferToClient {

    @SuppressWarnings("resource")

    public static void main(String[] args) throws IOException {

        long start = System.currentTimeMillis();

        // 打开socket的nio管道

        SocketChannel sc = SocketChannel.open();

        sc.connect(new InetSocketAddress("localhost", 9026));// 绑定相应的ip和端口

        sc.configureBlocking(true);// 设置阻塞

        // 将文件放到channel中

        FileChannel fc = new FileInputStream("C:/sss.txt").getChannel();// 打开文件管道

        //做好标记量

        long size = fc.size();

        int pos = 0;

        int offset = 4096;

        long curnset = 0;

        long counts = 0;

        //循环写

        while (pos<size) {

            curnset = fc.transferTo(pos, 4096, sc);// 把文件直接读取到socket chanel中，返回文件大小

            pos+=offset;

            counts+=curnset;

        }

        //关闭

        fc.close();

        sc.close();

        //打印传输字节数

        System.out.println(counts);

        // 打印时间

        System.out.println("bytes send--" + counts + " and totaltime--" + (System.currentTimeMillis() - start));

    }

}

Socket Nio代码：服务端

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.ServerSocket;

import java.nio.ByteBuffer;

import java.nio.channels.ServerSocketChannel;

import java.nio.channels.SocketChannel;

public class TransferToServer {

    public static void main(String[] args) throws IOException {

        // 创建socket channel

        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        ServerSocket ss = serverSocketChannel.socket();

        ss.setReuseAddress(true);// 地址重用

        ss.bind(new InetSocketAddress("localhost", 9026));// 绑定地址

        System.out.println("监听端口 : "

                + new InetSocketAddress("localhost", 9026).toString());

        // 分配一个新的字节缓冲区

        ByteBuffer dst = ByteBuffer.allocate(4096);

        // 读取数据

        while (true) {

            SocketChannel channle = serverSocketChannel.accept();// 接收数据

            System.out.println("Accepted : " + channle);

            channle.configureBlocking(true);// 设置阻塞，接不到就停

            int nread = 0;

            while (nread != -1) {

                try {

                    nread = channle.read(dst);// 往缓冲区里读

                    byte[] array = dst.array();//将数据转换为array

                    //打印

                    String string = new String(array, 0, dst.position());

                    System.out.print(string);

                    dst.clear();

                } catch (IOException e) {

                    e.printStackTrace();

                    nread = -1;

                }

            }

        }

    }

}

5.3. 阻塞/非阻塞、同步/非同步

　　阻塞 IO 和非阻塞 IO 这两个概念是程序级别的。主要描述的是程序请求操作系统 IO 操作后，如果 IO 资源没有准备好，那么程序该如何处理的问题：

前者等待；后者继续执行（并且使用线程一直轮询，直到有 IO 资源准备好了）

　　同步 IO 和非同步 IO，这两个概念是操作系统级别的。主要描述的是操作系统在收到程序请求 IO 操作后，如果 IO 资源没有准备好，该如何响应程序

的问题：前者不响应，直到 IO 资源准备好以后；后者返回一个标记（好让程序和自己知道以后的数据往哪里通知），当 IO 资源准备好以后，再用事件机

制返回给程序

巴特西