簡介：BIO：同步阻塞式IO，伺服器實現模式為一個連線一個執行緒，即客戶端有連線請求時伺服器端就需要啟動一個執行緒進行處理，如果這個連線不做任何事情會造成不必要的執行緒開銷，當然可以通過執行緒池機制改善。 NIO：同步非阻塞式IO，伺服器實現模式為一個請求一個執行緒，即客戶端傳送的連線請求都會註冊到多路複用器上，多路複用器輪詢到連線有I/O請求時才啟動一個執行緒進行處理。 BIO網路程式設計的基本模型是C/S模型，即兩個程序間的通訊。 服務端提供IP和監聽埠，客戶端通過連線操作想服務端監聽的地址發起連線請求，通過三次握手連線，如果連線成功建立，雙方就可以通過套接字進行通訊。    傳統的同步阻塞模型開發中，ServerSocket負責繫結IP地址，啟動監聽埠；Socket負責發起連線操作。連線成功後，雙方通過輸入和輸出流進行同步阻塞式通訊。簡單的描述一下BIO的服務端通訊模型：採用BIO通訊模型的服務端，通常由一個獨立的Acceptor執行緒負責監聽客戶端的連線，它接收到客戶端連線請求之後為每個客戶端建立一個新的執行緒進行鏈路處理沒處理完成後，通過輸出流返回應答給客戶端，執行緒銷燬。即典型的一請求一應答通宵模型。

【傳統BIO通訊模型圖】

該模型最大的問題就是缺乏彈性伸縮能力，當客戶端併發訪問量增加後，服務端的執行緒個數和客戶端併發訪問數呈1:1的正比關係，Java中的執行緒也是比較寶貴的系統資源，執行緒數量快速膨脹後，系統的效能將急劇下降，隨著訪問量的繼續增大，系統最終就掛了。這種通訊模型在高併發的場景是沒法應用的。同步阻塞式I/O建立的Server原始碼：

package com.cherry.socket.bio;
import java.io.*;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @author 
 
[email protected]
 * @create 2018/4/13 9:24
 * @desc
 **/
public class BIOServerBootStrap {
    public static void main(String[] args) throws IOException {
        //1.Create ServerSocket
        ServerSocket serverSocket = new ServerSocket();
        //2.Set up the service listener port
        serverSocket.bind(new InetSocketAddress(9999));
        //Create a thread pool
        ExecutorService threadPool = Executors.newFixedThreadPool(150);
        while (true){
            //3.Waitting for request
            System.out.println("----waitting for request----");
            final Socket socket = serverSocket.accept();
            threadPool.submit(new Runnable() {
                public void run() {
                    try {
                        //4.Obtain user intent
                        InputStream is = socket.getInputStream();
                        InputStreamReader isr = new InputStreamReader(is);
                        BufferedReader br = new BufferedReader(isr);
                        StringBuilder sb = new StringBuilder();
                        String line = null;
                        while ((line=br.readLine())!=null){
                            sb.append(line);
                        }
                        System.out.println("----the message get by server---- : "+sb);
                        //5.client response
                        OutputStream os = socket.getOutputStream();
                        PrintWriter pw = new PrintWriter(os);
                        pw.println("server time"+new Date().toLocaleString());
                        pw.flush();
                        socket.shutdownOutput();//Tell the client to write the cut-off
                        //6.release the resource
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}
 

同步阻塞式I/O建立的Client原始碼：

package com.cherry.socket.bio;
import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
/**
 * @author [email protected]
 * @create 2018/4/13 11:07
 * @desc
 **/
public class BIOClientBootStrap {
    public static void main(String[] args) throws IOException {
        //1.Create client socket
        Socket socket = new Socket();
        //2.connect to the server
        socket.connect(new InetSocketAddress("127.0.0.1",9999));
        //3.makes requests to the server
        OutputStream os = socket.getOutputStream();
        PrintWriter pw = new PrintWriter(os);
        pw.println("Hello,This is Client 2");
        pw.flush();
        socket.shutdownOutput();//Tell the Server to write the cut-off
        //4.get the response
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        StringBuilder sb = new StringBuilder();
        String line =null;
        while ((line=br.readLine())!=null){
            sb.append(line);
        }
        System.out.println("----The message get by client---- : "+sb);
        //5.release the resource
        socket.close();
    }
}

NIOnon-blocking IO， NIO提供了與傳統BIO模型中的Socket和ServerSocket相對應的SocketChannel和ServerSocketChannel兩種不同的套接字通道實現。新增的著兩種通道都支援阻塞和非阻塞兩種模式。阻塞模式使用就像傳統中的支援一樣，比較簡單，但是效能和可靠性都不好；非阻塞模式正好與之相反。對於低負載、低併發的應用程式，可以使用同步阻塞I/O來提升開發速率和更好的維護性；對於高負載、高併發的（網路）應用，應使用NIO的非阻塞模式來開發。NIO程式設計是面向通道的(BIO是面向流的)，流分為寫入/寫出，是單向的，意味著通道是可以進行雙向讀寫的。NIO所有基於channel的API對資料的操作都是間接通過操作緩衝區ByteBufferIn ： 磁碟 --通道--> ByteBuffer（記憶體）-->資料（記憶體）Out： 資料（記憶體）-->ByteBuffer（記憶體） --> 通道 --> 磁碟     NIO程式設計涉及ServerSocketChannel、SocketChannel、ByteBuffer、Selector（通道選擇器）
服務端原始碼：

package com.cherry.socket.nio;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
/**
 * @author [email protected]
 * @create 2018/4/13 11:34
 * @desc
 **/
public class NIOServerBootStrap {
    public static void main(String[] args) throws IOException {
        //1.Create ServerSocketChannel
        ServerSocketChannel ssc = ServerSocketChannel.open();
        //2.Set up the service listener port
        ssc.socket().bind(new InetSocketAddress(9999));
        //3.Set up the channel to be non-blocking
        ssc.configureBlocking(false);
        //4.Create channel selector
        Selector selector =Selector.open();
        //5.註冊事件型別
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        //6.遍歷事件處理列表
        while (true){
            int num = selector.select();
            if (num>0){
                //獲取所有待處理的keys
                Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
                while (keys.hasNext()){
                    SelectionKey key = keys.next();
                    //處理事件
                    if(key.isAcceptable()){
                        System.out.println("----key isAcceptable----");
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        SocketChannel socketChannel = channel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector,SelectionKey.OP_ACCEPT);
                    }else if (key.isReadable()){
                        System.out.println("----key isReadable(read)----");
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
                        while (true){
                            buffer.clear();
                            int n = channel.read(buffer);
                            if (n==1)break;
                            baos.write(buffer.array(),0,n);
                        }
                        channel.register(selector,SelectionKey.OP_WRITE,baos);
                    } else if (key.isWritable()){
                        System.out.println("----key isWritable(write)----");
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteArrayOutputStream baos = (ByteArrayOutputStream) key.attachment();
                        baos.write("_伺服器追加".getBytes());
                        ByteBuffer buffer = ByteBuffer.wrap(baos.toByteArray());
                        channel.write(buffer);
                        channel.socket().shutdownOutput();
                        channel.close();
                    }
                    //移除時間列表
                    keys.remove();
                }
            } else {
                continue;
            }
        }
    }
}

NettyNetty的通訊管道：通過AOP的程式設計思想(責任鏈設計模式)，實現訊息的編解碼。服務端程式設計：1）建立ServerBootstrap sbt=new ServerBootstrap();2）建立EventLoopGroup boss、worker3）關聯boss和worker> sbt.group(boss,worker);4）設定ServerSocketChannel實現類sbt.channel(NioServerSocketChannel);5）初始化通道sbt.childHandler(初始化通道);6）繫結埠並啟動服務ChannelFuture future=sbt.bind(port).sync();7）等待服務關閉 future.channel().closeFuture().sync();8) 釋放執行緒資源boss、worker # shutdownGraceFully();服務端原始碼：

package com.cherry.socket.netty.server;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
/**
 * @author [email protected]
 * @create 2018/4/16 9:51
 * @desc
 **/
public class ServerBootStrap {
    public static void main(String[] args) throws InterruptedException {
        //1.Create ServerBootstrap
        ServerBootstrap sbt = new ServerBootstrap();
        //2.Create thread pool(boss & worker)
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        //3.關聯執行緒池(boss負責請求轉發，worker負責事件處理)
        sbt.group(boss,worker);
        //4.Set up the server
        sbt.channel(NioServerSocketChannel.class);
        //5.Initialize the communication channel (key point)
        sbt.childHandler(new ServerChannelInitizlizer());
        //6.Bind listening port
        System.out.println("我在@9999埠監聽...");
        ChannelFuture channelFuture = sbt.bind(9999).sync();
        //7.Wait for the server to close
        channelFuture.channel().closeFuture().sync();
        //l
        boss.shutdownGracefully();
        worker.shutdownGracefully();
    }
}

package com.cherry.socket.netty.server;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
/**
 * @author [email protected]
 * @create 2018/4/16 10:26
 * @desc
 **/
public class ServerChannelHander extends ChannelHandlerAdapter {

    /*捕獲資料在通道傳輸過程中的異常*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.err.println("錯誤："+cause.getMessage());
    }
    /*接收資料，並響應*/
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ChannelFuture channelFuture = ctx.writeAndFlush(msg);
        //關閉通道
        channelFuture.addListener(ChannelFutureListener.CLOSE);
    }
}

package com.cherry.socket.netty.server;
import com.cherry.socket.netty.server.ServerChannelHander;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
/**
 * @author [email protected]
 * @create 2018/4/16 10:02
 * @desc
 **/
public class ServerChannelInitizlizer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //communication channel
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new ServerChannelHander());
    }
}

客戶端程式設計：1）建立Bootstrap sbt=new Bootstrap();2）建立EventLoopGroup worker3）關聯boss和worker> sbt.group(worker);4）設定SocketChannel實現類sbt.channel(NioSocketChannel);5）初始化通道sbt.handler(初始化通道);6）繫結埠並啟動服務ChannelFuture future=sbt.connect(host,port).sync();7）等待服務關閉 future.channel().closeFuture().sync();8）釋放執行緒資源worker # shutdownGraceFully();客戶端原始碼：

package com.cherry.socket.netty.client;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
/**
 * @author [email protected]
 * @create 2018/4/16 11:15
 * @desc
 **/
public class ClientBootStrap {
    public static void main(String[] args) throws InterruptedException {
        //1.Create Bootstrap
        Bootstrap bt = new Bootstrap();
        //2.Create thread pool(worker)
        EventLoopGroup worker = new NioEventLoopGroup();
        //3.關聯執行緒池
        bt.group(worker);
        //4.Set up the client
        bt.channel(NioSocketChannel.class);
        //5.Initialize the communication channel (key point)
        bt.handler(new ClientChannelInitializer());
        //6.連線
        ChannelFuture channelFuture = bt.connect("127.0.0.1",9999).sync();
        //7.Wait for the server to close
        channelFuture.channel().closeFuture().sync();
        //8.release the resource
        worker.shutdownGracefully();
    }
}

package com.cherry.socket.netty.client;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import javax.xml.transform.Source;
/**
 * @author [email protected]
 * @create 2018/4/16 11:22
 * @desc
 **/
public class ClientChannelHander extends ChannelHandlerAdapter {
    /*捕獲資料在通道傳輸過程的異常*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //super.exceptionCaught(ctx, cause);
        System.out.println("錯誤："+cause.getMessage());
    }
    /*接收資料*/
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //super.channelRead(ctx, msg);
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println(((ByteBuf)msg).toString(CharsetUtil.UTF_8));
    }
    /*連結伺服器時傳送資料*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //super.channelActive(ctx);
        ByteBuf buf = Unpooled.buffer();
        buf.writeBytes("你好，我是客戶端！".getBytes());
        ctx.writeAndFlush(buf);
    }
}

package com.cherry.socket.netty.client;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
/**
 * @author [email protected]
 * @create 2018/4/16 11:20
 * @desc
 **/
public class ClientChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //communication channel
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new ClientChannelHander());
    }
}

上述BIO NIO Netty所用的pom.xml

<!-- socket 相關  注意版本，不然有些方法不能用-->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>5.0.0.Alpha2</version>
</dependency>

通過對Netty的分析，我們將他的優點總結如下：1.API使用簡單，開發門檻低；2.功能強大，預設了很多編碼功能，支援多種主流協議；3.定製能力強，可以通過ChannelHandler對通訊框架進行靈活擴充套件；4.效能高，通過與其他的主流NIO框架對比，Netty的綜合性能最優；5.成熟，穩定，Netty修復了已經發現的所有JDK NIO BUG，業務開發人員不需要再為NIO的BUG煩惱；6.社群活躍，版本迭代週期短；7.經過大規模的商業應用考驗，質量得到驗證。Netty在網際網路、大資料、網路遊戲、企業應用、電信軟體等眾多領域已經得到了成功商用，也 證明他已經完全能滿足不同行業的商應用了；基於上述這些，我將在下一篇文章中寫一些關於如何實現高效能可擴充套件RPC,希望對大家有所幫助！