Java--网络编程之BIO

一、简介
1、基本概念区分
（1）同步：Java自己处理IO读写。
（2）异步：Java将IO读写委托给OS处理，将数据缓冲区地址和大小传给OS，完成后OS通知Java处理。
（3）阻塞：调用后会一直阻塞到读写完成后再返回。
（4）非阻塞：如果不能立马读写，调用后就会马上返回，当IO事件分发器通知可再次读写时再进行读写，不断循环直到读写完成。
2、关于BIO、NIO、AIO模型
（1）BIO：同步并阻塞
服务器的实现模式为：一个连接，一个线程。
缺点：客户端连接数与服务端连接数成正比，容易造成不必要的线程开销，甚至导致内存溢出。
（2）NIO：同步非阻塞
服务器的实现模式为：多个请求，一个线程。请求会注册在IO复用器selector上，多路复用器轮询，直到连接有IO请求时才启动一个线程进行处理。
（3）AIO：异步非阻塞
服务器的实现模式为：多个有效请求，一个线程。客户端的IO请求会由OS先完成再通知服务器应用去启动线程处理。
二、BIO编程
1、服务端代码实现

import java.io.*;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOServerDemo {
    public static void main(String[] args) {
        try {
            //创建ServerSocket实例
            ServerSocket serverSocket = new ServerSocket();

            //绑定端口
            serverSocket.bind(new InetSocketAddress(8889));
            System.out.println("服务端启动");

            //监听
            Socket accept = serverSocket.accept();

            //读
            InputStream inputStream = accept.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

            //回复
            OutputStream outputStream = accept.getOutputStream();
            String s;
            while((s=bufferedReader.readLine())!=null){
                System.out.println(accept.getRemoteSocketAddress()+":"+s);
                outputStream.write((s+"\n").getBytes());
                outputStream.flush();
            }
            bufferedReader.close();
            serverSocket.close();
            accept.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2、客户端代码实现

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Scanner;

public class BIOClientDemo {
    public static void main(String[] args) {
        try {
            //创建Socket实例
            Socket socket = new Socket();

            //连接服务器，端口号与服务端对应
            socket.connect(new InetSocketAddress("127.0.0.1",8889));

            //写
            OutputStream outputStream = socket.getOutputStream();

            //接受服务端返回的消息
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            Scanner s=new Scanner(System.in);
            s.useDelimiter("\n");

            String str;
            while(s.hasNext()){
                str=s.nextLine();
                outputStream.write((str+"\n").getBytes());
                String recv=bufferedReader.readLine();
                System.out.println("echo:"+recv);
            }
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3、BIO+多线程，客户端代码不变，修改服务端代码，以接收多个客户端的连接
服务端代码类：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOMultiConnectDemo {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket();
            serverSocket.bind(new InetSocketAddress(8889));
            System.out.println("服务器启动");
        } catch (IOException e) {
            e.printStackTrace();
        }
       while(true){
           try {
               Socket accept = serverSocket.accept();
               new Thread(new BIOMultiDemo(accept)).start();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
    }
}

多线程实现代码类：

import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOMultiDemo implements Runnable {
    private SocketChannel socketChannel;
    Selector selector;

    public NIOMultiDemo(SocketChannel socketChannel) {
        this.socketChannel = socketChannel;
        try {
            selector = Selector.open();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            int n = selector.select();
            while (n > 0) {
                Iterator iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = (SelectionKey) iterator.next();
                    iterator.remove();
                    if (selectionKey.isAcceptable()) {
                        //有可接受的事件完成
                        ServerSocketChannel serverSocketChannel1 = (ServerSocketChannel) selectionKey.channel();

                        //接收用户的连接
                        socketChannel = serverSocketChannel1.accept();
                        System.out.println("客户端：" + socketChannel.getRemoteAddress());
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}