Netty原理及实现

Netty底层实现是由NIO实现的；

以下实现基于版本：

Maven 3.3

Netty 4.1.22

Netty是什么？

• 异步事件驱动框架，用于快速开发高性能服务端和客户端；
• 封装了JDK底层BIO和NIO模型，提供高度可用的API；
• 自带编码解码器解决拆包粘包问题，用户只需要关心业务逻辑；
• 精心设计的Reactor线程模型支持高并发海量连接；
• 自带协议栈，无需用户关心；

 

进程（简单理解成一个应用） 它要去读写数据的时候，它会去做一个系统调用（简单理解：API的调用），

到内核以后，它会去准备数据，数据准备过来之后把数据复制过去，（为什么要复制，因为此时数据是在内存的缓冲区里面的，要复制要用户缓冲区打到网卡的buf上面去）数据没有复制好的话，整个进程的阻塞的；

unix处理过程：首先有一个进程通过系统调用到了内核，此时系统调用是不阻塞的，不管内核怎么处理，内核处理好数据了告之数据准备好了，通知去取数据时候有可能这个数据还在复制，还会去阻塞，这个过程复制结束的话，这段也是没有阻塞的；所以它这种模型叫同步非阻塞模型；

Unix网络编程5种I/O模型

IO复用模型：进行经过系统调用进入内核，等待数据准备这段过程是阻塞的，数据准备好的之后告之，在经过

系统调用，它是用一个线程复用了整个事件，这个事件既可以为A客户端去服务，也可以为B客户端去服务，

这个线程轮询一个事件是非常短的，很快就结束了，性能瓶颈还谈不上，对程序来说完全感知不到；

IO复用模型阻塞的

这个是普及知识点，

什么是信号驱动的IO模型呢》》

首先有系统调用到内核，数据准备好了就主动通知，这个进程知道数据准备好了之后经过系统调用但是这个过程会

阻塞，等待数据复制完返回；

信号驱动的IO模型非阻塞

异步IO模型：

首先有个系统调用， 到内核，只要这个过程调用完，这个进程就返回了，返回之后它会注册一个事件，或者注册一个回调

然后告诉内核，数据复制完了之后才告之，数据复制完了之后它就会去取数据；

异步IO模型 非阻塞

JAVA IO 模型

2.1、1:1同步阻塞IO通信模型

Acceptor相当于门卫，Client1，2….N相当于你的朋友，Thread1，2，,,,N就类比于你的分身，来接待这些朋友;

这样的模型会发生什么问题：主要问题是要分配的线程太多；

加了线程池之后有些改善，一个客户请求过来处理时，可以不用再创建连接，节省了时间和性能，放在线程池中，用完之后归还

问题：

          线程池满了，后面的请求就需要等待；

          读和写的操作都是同步的，同步：比如一个客户端建立一个连接，发了一条数据过去，服务端在处理，该客户端是不能再做别的事情，等待结果返回；

          I/O线程和业务线程它们的速度是不匹配的，也就是说速度差会存在，这样会导致它的可靠性非常差；

简单的BIO代码实现：

日志的依赖：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.20</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.5</version>
</dependency>

@Slf4j
publicclassServer{
   ..
}

这样就不用LoggerFactory了

Server类

package com.yz.study.bio;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * BIO 服务端编码
 */

public class Server {

    private static Logger log = LoggerFactory.getLogger(Server.class);

    //默认的端口号
    private static int DEFAULT_POST = 7777;

    //单例的ServerSocket
    private static ServerSocket serverSocket;

    //
    public static void start() throws IOException {

        //
        start(DEFAULT_POST);

    }

    //这个方法不会被大量并发访问，不太需要考虑效率问题，直接进行方法同步就行了
    private synchronized static void start(int port) throws IOException {
        //做一个容错处理
        if (serverSocket != null) {
            return;
        }
        try {
            /*
             * 通过构造函数创建ServerSocket
             * 如果端口合法且空闲，服务端就监听成功
             */
            serverSocket = new ServerSocket(port);
            log.info("服务端已启动！端口号:" + port);
            System.out.println("服务端已启动！端口号:" + port);
            /*
             *  自旋
             *  通过无线循环监听客户端连接
             *  如果没有客户端接入，将阻塞在accept操作上。
             */
            for(;;){

                /*
                 * 源码
                 *
                  protected synchronized void accept(SocketImpl s) throws IOException {
                    if (s instanceof PlainSocketImpl) {
                        // pass in the real impl not the wrapper.
                        SocketImpl delegate = ((PlainSocketImpl)s).impl;
                        delegate.address = new InetAddress();
                        delegate.fd = new FileDescriptor();
                        impl.accept(delegate);
                        // set fd to delegate's fd to be compatible with older releases
                        s.fd = delegate.fd;
                    } else {
                        impl.accept(s);
                    }
                }


                protected void accept(SocketImpl s) throws IOException {
                    acquireFD();
                    try {
                        socketAccept(s);
                    } finally {
                        releaseFD();
                    }
                }


                void releaseFD() {
                    synchronized (fdLock) {
                        fdUseCount--;
                        if (fdUseCount == -1) {
                            if (fd != null) {
                                try {
                                    socketClose();
                                } catch (IOException e) {
                                } finally {
                                    fd = null;
                                }
                            }
                        }
                    }
                }
                 */
                Socket socket = serverSocket.accept();
                new Thread(new ServerHandler(socket)).start();
            }
        } finally {
            //一些必要的清理工作
            if (serverSocket != null) {
                log.info("服务端已关闭");
                System.out.println("服务端已关闭");
                serverSocket.close();
                serverSocket = null;
            }
        }
    }

}

ServerHandler类

package com.yz.study.bio;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class ServerHandler implements Runnable {
    private static Logger log = LoggerFactory.getLogger(ServerHandler.class);
    private Socket socket;

    public ServerHandler() {
    }

    public ServerHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;

        try {
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(), true);
            String expression;
            String result;
            while (true) {
                if ((expression = in.readLine()) == null) {
                    break;
                }
                log.info("服务端收到信息:"+expression);
                System.out.println("服务端收到信息:"+expression);
                result = Calculator.cal(expression);
                out.println(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
            log.error(e.getLocalizedMessage());
            System.out.println(e.getLocalizedMessage());
        } finally {
            if(in !=null){
                try{
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;
            }
            if(out !=null){
                    out.close();
                    out = null;
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket =null;

            }

        }
    }
}

Client类

package com.yz.study.bio;

import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

    private static org.slf4j.Logger logger = LoggerFactory.getLogger(Client.class);

    private static int DEFAULT_SERVER_PORT = 7777;
    private static String DEFAULT_SERVER_IP = "127.0.0.1";

    public static void send(String expression) {

        send(DEFAULT_SERVER_PORT, expression);

    }

    public static void send(int port, String expression) {
        logger.info("算术表达式为：" + expression);
        System.out.println("算术表达式为：" + expression);
        Socket socket = null;

        BufferedRe