BIO、NIO实战

BIO

BIO：blocking IO，分别写一个服务端和客户端交互的C/S实例。
服务器端：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;

/**
 * Created by atai on 2019/3/19.
 */
public class BIOServer {

    private String host;

    private int port;

    private static Charset charset = Charset.forName("UTF-8");

    public static void main(String[] args) {
        int port = 9010;
        try (ServerSocket ss = new ServerSocket(port)) {
            while (true) {
                Socket s = ss.accept();
                BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream(), charset));

                String mess = null;
                while ((mess = reader.readLine()) != null) {
                    System.out.println(mess);
                }
                s.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端：

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.Charset;
import java.util.Scanner;

/**
 * Created by atai on 2019/3/19.
 */
public class BIOClient implements Runnable {

    private String host;

    private int port;

    private Charset charset = Charset.forName("UTF-8");

    public BIOClient(String host, int port) {
        super();
        this.host = host;
        this.port = port;
    }

    @Override
    public void run() {
        try (Socket s = new Socket(host, port); OutputStream out = s.getOutputStream();) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入：");
            String mess = scanner.nextLine();
            out.write(mess.getBytes(charset));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        BIOClient client = new BIOClient("localhost", 9010);
        client.run();
    }
}

启动时，记得先启动服务器代码，才能正常启动客户端代码，不然客户端会报连接异常（不存在可用端口号）。

上面的服务器端代码每次只能同时受理一个客户端请求，其他客户端此时只能等待，为了让服务端支持处理多个客户端请求，可以改造成多线程形式：

public class BIOServerV2 {

    private static Charset charset = Charset.forName("UTF-8");

    public static void main(String[] args) {
        int port = 9010;
        try (ServerSocket ss = new ServerSocket(port)) {
            while (true) {
                new Thread(new SocketProcess(ss.accept())).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class SocketProcess implements Runnable {

        Socket s;

        public SocketProcess(Socket s) {
            super();
            this.s = s;
        }

        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream(), charset))) {
                String mess = null;
                while ((mess = reader.readLine()) != null) {
                    System.out.println(mess);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

１、理解什么是阻塞
２、思考：阻塞对服务端有什么影响？
３、阻塞时，服务端什么也干不了，不能处理其他客户端的连接，如何改进？
４、多线程
５、如果并发请求量很大，比如一万、十万，会有什么问题？
６、32位系统1个线程对象默认最大需要320KB内存，64位系统默认最大需要1M内存，业务对象也需要内存，内存会不足。过多的线程需要OS频繁切换，也会大大影响性能。
７、怎么办？
８、线程池

既然使用线程池可以避免频繁创建、销毁、切换线程，那就写一个使用线程池的服务端实现：

public class BIOServerV3 {

    private static Charset charset = Charset.forName("UTF-8");

    public static void main(String[] args) {
        int port = 9010;
        int threads = 100;
        ExecutorService tpool = Executors.newFixedThreadPool(threads);

        try (ServerSocket ss = new ServerSocket(port)) {
            while (true) {
                Socket s = ss.accept();
                // 丢到线程池中执行
                tpool.execute(new SocketProcess(s));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        tpool.shutdown();
    }

    static class SocketProcess implements Runnable {

        Socket s;

        public SocketProcess(Socket s) {
            super();
            this.s = s;
        }

        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream(), charset))) {
                String mess = null;
                while ((mess = reader.readLine()) != null) {
                    System.out.println(mess);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

９、阻塞对线程池的方式有什么影响？
１０、阻塞等待接收客户端的数据时，这段时间占着线程，而池中线程数是有限的，并发量大时，将导致没有线程处理请求，请求的响应时间长，甚至拒绝服务。
１１、如果能不阻塞，在没有数据时，就去干点别的事情，有数据了才处理数据那该多好。
这个时候，终于等到NIO闪亮登场。

NIO

NIO：new IO，java1.4开始推出的可非阻塞IO，在java.io包中。特点如下：
１、可解决BIO阻塞的不足；
２、但比BIO学习、使用复杂；
３、可以以阻塞、非阻塞两种方式工作；
４、在非阻塞模式下，可以用少量（甚至一个）线程处理大量的IO连接；
５、Java7推出了NIO.2（又称AIO，即异步IO）

Select选择器：非阻塞模式下，一个选择器可检测多个SelectableChannel，获得为读写等操作准备好的通道，就不需要我们用循环去判断了。

Selector的用法：
１、创建Selector

Selector selector = new Selector.open();

２、将要交给Selector检测的SelectableChannel注册进来

channel.configureBlocking(false); // 注意：一定要设为非阻塞模式
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

channel.register方法的第二个参数指定要selector帮忙监听的就绪操作：

SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE

３、通过Selector来选择就绪的Channel，有三个select方法

int select()             // 阻塞直到有就绪的Channel
int select(long timeout) // 阻塞最长多久
int selectNow()          // 不阻塞这

这三个方法返回值：就绪的Channel数量

int n = selector.select();

注意：select()方法返回当前的就绪数量。

４、获得就绪的SelectionKey集合（当有就绪的Channel时）

Set<SelectionKey> selectedKey = selector.selectedKeys();

５、处理selectedKeys set（详见后面的服务端代码）

Channel通道：数据的来源或去向目标

１、Channel的实现

　　FileChannel（只能用于BIO）
　　DatagramChannel
       SocketChannel
       SocketChannel
       ServerSocketChannel

２、各Channel的API方法

open()：创建通道
       read(Buffer)：从通道中读取数据放入到buffer
       write(Buffer)：将buffer中的数据写给通道

Buffer缓冲区，数据的临时存放区

ByteBuffer、MappedByteBuffer、CharBuffer、DoubleBuffer等

Buffer的基本使用步骤：
１、调用xxxBuffer.allocate(int)创建Buffer

２、调用put方法往Buffer中写数据

３、调用buffer.flip()将buffer转为读模式

４、读取buffer中的数据

５、清理数据buffer.clear()，整理数据buffer.compact()

Buffer的三个重要属性capacity、position、limit

以下是NIO代码的具体实例。

服务器端：

public class NioServer {

    private static Charset charset = Charset.forName("UTF-8");
    private static CharsetDecoder decoder = charset.newDecoder();

    public static void main(String[] args) throws IOException {
        // 创建一个selector
        Selector selector = Selector.open();
        ServerSocketChannel ssc = ServerSocketChannel.open();
        int port = 9200;
        ssc.bind(new InetSocketAddress(port));

        // 2注册到selector
        // 设置非阻塞
        ssc.configureBlocking(false);
        // ssc向selector注册，监听连接到来
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        // 连接的计数
        int connectionCount = 0;
        // 极少量线程
        int threads = 3;
        ExecutorService tpool = Executors.newFixedThreadPool(threads);

        while (true) {
            // 阻塞等待就绪的事件
            int readyChannelCount = selector.select();
            if (readyChannelCount == 0) {
                continue;
            }
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                if (key.isAcceptable()) {
                    // a connection was accepted by a ServerSocketChannel.
                    ServerSocketChannel ssssc = (ServerSocketChannel) key.channel();
                    // 接收连接
                    SocketChannel cc = ssssc.accept();

                    // 请selectoror帮忙监测数据到了没
                    cc.configureBlocking(false);
                    // 向selector注册
                    cc.register(selector , SelectionKey.OP_READ, ++connectionCount);
                } else if (key.isConnectable()) {
                    // a connection was established with a remote server.
                } else if (key.isReadable()) {
                    // a channel is ready for reading
                    // 交给线程池去处理数据读
                    tpool.execute(new SocketProcess(key));
                    // 取消Selector注册，防止线程池处理不及时，重复选择
                    key.cancel();
                } else if (key.isWritable()) {
                    // a channel is ready for writing
                }
                // 处理后，一定要从selectedKey集合中移除
                keyIterator.remove();
            }
        }
    }

    static class SocketProcess implements Runnable {

        SelectionKey key;

        public SocketProcess(SelectionKey key) {
            super();
            this.key = key;
        }

        @Override
        public void run() {
            try {
                System.out.println("连接" + key.attachment() + " 发来了：" + readFromChannel());
                key.channel().close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        private String readFromChannel() throws IOException {
            SocketChannel sc = (SocketChannel) key.channel();

            int bfsize = 1024;
            ByteBuffer rbf = ByteBuffer.allocateDirect(bfsize);

            // 定义一个更大的buffer
            ByteBuffer bigBf = null;

            // 读的次数
            int count = 0;
            while ((sc.read(rbf) != -1)) {
                count++;
                ByteBuffer temp = ByteBuffer.allocateDirect(bfsize * (count + 1));
                if (bigBf != null) {
                    // 将buffer由写转为读模式
                    bigBf.flip();
                    temp.put(bigBf);
                }
                bigBf = temp;
                // 将这次读到的数据放入大buffer
                rbf.flip();
                bigBf.put(rbf);
                // 为了下次读，清理Buffer
                rbf.clear();
            }

            if (bigBf != null) {
                bigBf.flip();
                try {
                    // 将字节转为字符，返回接收到的字符串
                    return decoder.decode(bigBf).toString();
                } catch (CharacterCodingException e) {
                    e.printStackTrace();
                }
            }

            return null;
        }
    }
}

客户端：

public class NioClient {

    private static Charset charset = Charset.forName("UTF-8");

    public static void main(String[] args) {
        try (SocketChannel sc = SocketChannel.open()) {
            boolean connected = sc.connect(new InetSocketAddress("localhost", 9200));
            System.out.println("connected=" + connected);
            // 写
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入：");
            String mess = scanner.nextLine();
            ByteBuffer bf = ByteBuffer.wrap(mess.getBytes(charset));

            while (bf.hasRemaining()) {
                int writedCount = sc.write(bf);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}