深度解析Java NIO底层实现原理（初探服务器端程序）

淩亂°似流年 2022-10-09 12:28 252阅读 0赞

> 原创不易，转载请注明出处  
> java 版本1.8

### 文章目录 ###

*   *   *  前言
         *  1.一段基于java nio实现的服务端程序
         *  2.ServerSocketChannel是怎样open的
         *  3.ServerSocketChannel\#bind实现原理
         *   *  3.1 bind
             *  3.2 listen
         *  总结

--------------------

### 前言 ###

本文主要从源码角度剖析java nio，文章定位属于高级进阶篇，所以在看本文之前需要有几点要求：

1.  对java nio有所了解，同时也需要对linux 网络编程有所了解，特别是epoll。
2.  本文分析的jdk源码是1.8，因为java nio根据不同操作系统有不同的底层实现，我们为了更贴近生产级别，会剖析基于linux实现的那部分，所以我们手里需要有份openjdk的源码。

本系列文章将会从一段基于java nio实现的程序代码开始，然后一行一行代码进行剖析，看看底层实现原理是啥样的。

### 1.一段基于java nio实现的服务端程序 ###

我这里直接贴上一段基于java nio实现的服务端程序代码，如果你看不懂该程序，需要补充java nio基础。

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);
    InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
    SocketAddress socketAddress=new InetSocketAddress(inetAddress, 12020);
    serverSocketChannel.bind(socketAddress);
    Selector selector = Selector.open();
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    while (true){ 
        int select = selector.select();
        if (select>0){ 
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()){ 
                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()){ 
                    ServerSocketChannel channel =(ServerSocketChannel)selectionKey.channel();
                    SocketChannel socketChannel = channel.accept();
                    socketChannel.configureBlocking(false);
                    // 处理
                    processConnect(socketChannel);
                    //可读事件
                }else if (selectionKey.isReadable()){ 
                    SelectableChannel channel = selectionKey.channel();
                    processRead(channel);
                    // 可写事件
                }else if (selectionKey.isWritable()){ 
    
                    SelectableChannel channel = selectionKey.channel();
                    processWrite(channel);
                }
                iterator.remove();
            }
        }
    }

这里稍微解释一下这段代码，其实就是打开一个serverSocketChannel，然后这个socketChannel监听这个端口，打开一个selector，将serverSocketChannel注册到selector上面，然后，告诉selector当前这个channel关心accpet事件。  
下面的while循环就是不断的进行select，这里select其实就是等待事件的发生，比如说有个客户端连接这个服务器程序，这个时候就会触发accpet事件的发生，select就会从阻塞状态唤醒，否则就会一直堵塞等待事件的发生。如果事件发送，则会返回有多少个事件。  
可以拿到事件，然后进行处理，也就是里面循环那段。

### 2.ServerSocketChannel是怎样open的 ###

首先我们先来分析一下上面程序的第一行

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

看看这个ServerSocketChannel是怎样打开的。

public static ServerSocketChannel open() throws IOException { 
        return SelectorProvider.provider().openServerSocketChannel();
    }

可以看到，调用provider的openServerSocketChannel方法  
看看这个provider是怎样来的

public static SelectorProvider provider() { 
            synchronized (lock) { 
                if (provider != null)
                    return provider;
                return AccessController.doPrivileged(
                    new PrivilegedAction<SelectorProvider>() { 
                        public SelectorProvider run() { 
                                if (loadProviderFromProperty())
                                    return provider;
                                if (loadProviderAsService())
                                    return provider;
                                provider = sun.nio.ch.DefaultSelectorProvider.create();
                                return provider;
                            }
                        });
            }
        }

如果provider不是null的话，就直接返回，程序一开始的时候，这个provider肯定是null，就会走下面那一大堆  
先是从Property 加载，如果没有的话就会从service中加载，也就是使用spi的方式加载，如果还没有的话，就调用DefaultSelectorProvider进行create。  
从property这段代码我就不贴出来了，主要是下面这行代码

System.getProperty("java.nio.channels.spi.SelectorProvider");

从spi中加载我也不多介绍了，主要是这段代码。

ServiceLoader<SelectorProvider> sl =
                ServiceLoader.load(SelectorProvider.class,
                                   ClassLoader.getSystemClassLoader());

说下最后DefaultSelectorProvider，这个在不同的操作系统下面会有不同的类  
linux系统的在solaris 这个文件夹下面。  
我直接把create方法代码贴出来

public static SelectorProvider create() { 
            String osname = AccessController
                .doPrivileged(new GetPropertyAction("os.name"));
            if (osname.equals("SunOS"))
                return createProvider("sun.nio.ch.DevPollSelectorProvider");
            if (osname.equals("Linux"))
                return createProvider("sun.nio.ch.EPollSelectorProvider");
            return new sun.nio.ch.PollSelectorProvider();
        }

如果是sunos，话就是创建sun.nio.ch.DevPollSelectorProvider ，如果是linux系统的话sun.nio.ch.EPollSelectorProvider  
这个时候provider就有着落了，他这里createProvider方法我们就不看了，就是反射创建的对象。  
直接看看EPollSelectorProvider

public class EPollSelectorProvider
        extends SelectorProviderImpl
    { 
        public AbstractSelector openSelector() throws IOException { 
            return new EPollSelectorImpl(this);
        }
    
        public Channel inheritedChannel() throws IOException { 
            return InheritedChannel.getChannel();
        }
    }

你会发现EPollSelectorProvider 没有openServerSocketChannel 方法，这个时候我们就要找他的父类SelectorProviderImpl了，这个类不同操作系统下面是通用的。

public ServerSocketChannel openServerSocketChannel() throws IOException { 
            return new ServerSocketChannelImpl(this);
     }

可以看到创建了一个ServerSocketChannelImpl ，构造就是这个provider。  
可以看下这个ServerSocketChannelImpl 类的定义

class ServerSocketChannelImpl extends ServerSocketChannel implements SelChImpl

接着看下构造实现。

ServerSocketChannelImpl(SelectorProvider var1) throws IOException { 
            super(var1);
            this.fd = Net.serverSocket(true);
            this.fdVal = IOUtil.fdVal(this.fd);
            this.state = 0;
    }

调用Net.serverSocket(true)方法，创建了一个socket，并且返回一个文件描述符对象。

看下这个方法的实现。

static FileDescriptor serverSocket(boolean var0) { 
            return IOUtil.newFD(socket0(isIPv6Available(), var0, true));
    }

先是调用socket0(isIPv6Available(), var0, true) 方法获取到一个fd，也就是文件描述符，然后就是调用IOUtil.newFD 方法将这个文件描述符包装成了一个文件描述符对象。  
看看这个socket0方法

private static native int socket0(boolean var0, boolean var1, boolean var2);

这里native方法，就需要找openjdk源码了，在jdk\\src\\solaris\\native\\sun\\nio\\ch\\Net.c路径下有Net类的native方法实现，直接搜socket0就可以了。

JNIEXPORT int JNICALL
    Java_sun_nio_ch_Net_socket0(JNIEnv *env, jclass cl, jboolean preferIPv6,
                                jboolean stream, jboolean reuse)
    { 
        int fd;
        int type = (stream ? SOCK_STREAM : SOCK_DGRAM);
    #ifdef AF_INET6
        int domain = (ipv6_available() && preferIPv6) ? AF_INET6 : AF_INET;
    #else
        int domain = AF_INET;
    #endif
    
        fd = socket(domain, type, 0);
        if (fd < 0) { 
            return handleSocketError(env, errno);
        }
    ...
        return fd;
    }

我这里省略了一些代码，留下了最关键的代码。

fd = socket(domain, type, 0);

直接就是调用c语言的socket函数。并将文件描述符fd 返回。  
关于IOUtils是怎样将fd包装成一个FileDescriptor 文件描述符对象我们就不看，其实就是创建FileDescriptor对象，将fd赋值到FileDescriptor的fd成员中。

接着回到ServerSocketChannelImpl 的构造方法中。

this.fdVal = IOUtil.fdVal(this.fd);

这行其实就是将FileDescriptor 文件描述符对象中的fd字段提取出来赋值到 fdVal 上面，这里没有什么好说的。  
最后就是将state设置成0。  
到这里我们的ServerSocketChannel.open(); 这行代码就剖析完了。

### 3.ServerSocketChannel\#bind实现原理 ###

接着我们看下`serverSocketChannel.bind(socketAddress);`这行代码实现原理，其实就是然后socket监听某个端口。

public final ServerSocketChannel bind(SocketAddress local)
        throws IOException{ 
        return bind(local, 0);
    }

public ServerSocketChannel bind(SocketAddress local, int backlog) throws IOException { 
        synchronized (lock) { 
            if (!isOpen())
                throw new ClosedChannelException();
            if (isBound())
                throw new AlreadyBoundException();
            InetSocketAddress isa = (local == null) ? new InetSocketAddress(0) :
                Net.checkAddress(local);
            SecurityManager sm = System.getSecurityManager();
            if (sm != null)
                sm.checkListen(isa.getPort());
            NetHooks.beforeTcpBind(fd, isa.getAddress(), isa.getPort());
    
            // bind操作
            Net.bind(fd, isa.getAddress(), isa.getPort());
            // listen操作
            Net.listen(fd, backlog < 1 ? 50 : backlog);
            synchronized (stateLock) { 
                localAddress = Net.localAddress(fd);
            }
        }
        return this;
    }

两个参数，第一个就是监听的地址，第二个是backlog，也就是半连接队列长度（不理解的可以看下建立连接三次握手的过程）  
首先是判断是否打开，这个我们在open的时候就已经打开，接着判断是否已经bind，显然这个也是没有的，接着就是看看端口有没有被占用，调用Net.bind方法进行绑定。调用Net.listen进行端口的监听。最后就是赋值localAddress ，这个一旦赋值就代表Bound成功。  
这里面最最重要的就是Net.bind 与 Net.listen，接下来我们看看他们底层实现原理

#### 3.1 bind ####

public static void bind(FileDescriptor fd, InetAddress addr, int port)
        throws IOException{ 
        bind(UNSPEC, fd, addr, port);
    }

static void bind(ProtocolFamily family, FileDescriptor fd,
                     InetAddress addr, int port) throws IOException
    { 
        boolean preferIPv6 = isIPv6Available() &&
            (family != StandardProtocolFamily.INET);
        bind0(fd, preferIPv6, exclusiveBind, addr, port);
    }

private static native void bind0(FileDescriptor fd, boolean preferIPv6,
                                     boolean useExclBind, InetAddress addr,
                                     int port)
        throws IOException;

到这里，可以看到是调用的native方法，我们直接找到Net.c 的bind0 实现

JNIEXPORT void JNICALL
    Java_sun_nio_ch_Net_bind0(JNIEnv *env, jclass clazz, jobject fdo, jboolean preferIPv6,
                              jboolean useExclBind, jobject iao, int port)
    { 
        SOCKADDR sa;
        int sa_len = SOCKADDR_LEN;
        int rv = 0;
       // 将InetAddress 转成sockaddr结构体
        if (NET_InetAddressToSockaddr(env, iao, port, (struct sockaddr *)&sa, &sa_len, preferIPv6) != 0) { 
          return;
        }
    // 进行bind
        rv = NET_Bind(fdval(env, fdo), (struct sockaddr *)&sa, sa_len);
        if (rv != 0) { 
            handleSocketError(env, errno);
        }
    }

开始就是将java 的InetAddress 转成 sockaddr 结构体。  
接着调用NET\_Bind 函数进行绑定，这个NET\_Bind 函数在net\_util\_md.c中

int
    NET_Bind(int fd, struct sockaddr *him, int len)
    { 
    省略若干代码...
        rv = bind(fd, him, len);
    省略若干代码...
        return rv;
    }

可以看到，最终还是调用了c函数bind进行绑定

#### 3.2 listen ####

看看Net.listen(fd, backlog < 1 ? 50 : backlog);这行代码是怎样完成监听的，第一个参数是fd，socket套接字文件描述符，第二个就是半连接队列长度，如果小于1的话，就设置成50，否则用你的那个。  
看看Net的listen方法。

static native void listen(FileDescriptor fd, int backlog) throws IOException;

native方法，直接看下Net.c里对应的listen方法

JNIEXPORT void JNICALL
    Java_sun_nio_ch_Net_listen(JNIEnv *env, jclass cl, jobject fdo, jint backlog)
    { 
        if (listen(fdval(env, fdo), backlog) < 0)
            handleSocketError(env, errno);
    }

可以看到，直接调用的c的listen函数进行监听

### 总结 ###

ServerSocketChannel.open(); 很简单，就是通过provider创建一个ServerSocketChannelImpl 对象，创建对象的同时通过调用c语言的socket函数创建一个套接字的描述符，最后将描述符返回保存到ServerSocketChannelImpl 对象中。  
接着就是serverSocketChannel.bind(socketAddress)，这个里面干了两个事，一个bind，一个是listen。  
下篇我们将接着往下剖析。