3. Java Socket实现

1. SocketImpl的类树如下：

java.net.SocketImpl（抽象类）
    --> java.net.AbstractPlainSocketImpl（抽象实现类）
        --> java.net.TwoStacksPlainSocketImpl（真正实现类，Vista以下版本）
        --> java.net.DualStackPlainSocketImpl（真正实现类，Vista及以上版本）
        --> java.net.PlainSocketImpl（上述实现类的代理类）
            --> java.net.SocksSocketImpl（SOCKS TCP套接字实现类）

2. 类字段

• SocketImpl

// 指向服务器或客户端实例，只能有一个非空
Socket socket = null;
ServerSocket serverSocket = null;

// 套接字文件描述符
FileDescriptor fd;
// 远端IP地址
InetAddress address;
// 远端端口
int port;
// 本地端口
int localport;

• PlainSocketImpl

// 代理真正的套接字实例
// TwoStacksPlainSocketImpl或DualStackPlainSocketImpl
AbstractPlainSocketImpl impl;

• ServerSocket

// 指向套接字代理类实例（SocksSocketImpl）
SocketImpl impl;

// 状态
// 是否创建套接字
boolean created = false;
// 是否绑定本地地址
boolean bound = false;
// 是否关闭套接字
boolean closed = false;

• Socket

// 指向套接字代理类实例（SocksSocketImpl）
SocketImpl impl;

// 状态
// 是否创建套接字
boolean created = false;
// 是否绑定本地地址
boolean bound = false;
// 是否建立连接
boolean connected = false;
// 是否关闭读
boolean shutIn = false;
// 是否关闭写
boolean shutOut = false;
// 是否关闭套接字
boolean closed = false;

3. 创建套接字

• ServerSocket

创建真正套接字实例：

public ServerSocket() throws IOException {
    setImpl();
}

// ServerSocket
private void setImpl() {
    // SocketImpl#impl
    impl = new SocksSocketImpl();
    impl.setServerSocket(this);
}

SocksSocketImpl() {
    // Nothing needed
}

// SocksSocketImpl的父类
PlainSocketImpl() {
    if (useDualStackImpl) {
        // AbstractPlainSocketImpl#impl
        impl = new DualStackPlainSocketImpl(exclusiveBind);
    } else {
        impl = new TwoStacksPlainSocketImpl(exclusiveBind);
    }
}

public DualStackPlainSocketImpl(boolean exclBind) {
    // 套接字是否互斥绑定，Windows为true
    exclusiveBind = exclBind;
}

初始化套接字：

// ServerSocket
SocketImpl getImpl() throws SocketException {
    if (!created)
        createImpl();
    return impl;
}

// ServerSocket
void createImpl() throws SocketException {
    if (impl == null)
        setImpl();
    try {
        impl.create(true);
        created = true;
    } catch (IOException e) {
        throw new SocketException(e.getMessage());
    }
}

// AbstractPlainSocketImpl
void create(boolean stream) throws IOException {
    this.stream = stream;
    if (!stream) {
        // SocketImpl#fd
        fd = new FileDescriptor();
        try {
            // 创建数据报套接字UDP
            socketCreate(false);
        } catch (IOException ioe) {
            fd = null;
            throw ioe;
        }
    } else {
        fd = new FileDescriptor();
        // 创建流式套接字TCP
        socketCreate(true);
    }

    // Socket或ServerSocket置为已创建状态
    if (socket != null)
        socket.setCreated();
    if (serverSocket != null)
        serverSocket.setCreated();
}

// DualStackPlainSocketImpl
void socketCreate(boolean stream) throws IOException {
    // 调用native方法创建套接字
    int newfd = socket0(stream, false /*v6 Only*/);
    // SocketImpl#fd
    fdAccess.set(fd, newfd);
}

// ServerSocket：已创建
void setCreated() {
    created = true;
}

• Socket

public Socket() {
    setImpl();
}

void setImpl() {
    impl = new SocksSocketImpl();
    impl.setSocket(this);
}

SocketImpl getImpl() {
    if (!created)
        createImpl(true);
    return impl;
}

// 后续同ServerSocket

4. 服务器绑定本地地址

// ServerSocket
void bind(SocketAddress endpoint, int backlog) {
    // getImpl()触发套接字初始化
    // 绑定本地地址
    getImpl().bind(epoint.getAddress(), epoint.getPort());
    getImpl().listen(backlog);
}

//AbstractPlainSocketImpl
void bind(InetAddress address, int lport) {
    socketBind(address, lport);

    // Socket或ServerSocket置为已绑定状态
    if (socket != null)
        socket.setBound();
    if (serverSocket != null)
        serverSocket.setBound();
}

// DualStackPlainSocketImpl
void socketBind(InetAddress address, int port) {
    //  套接字文件描述符
    int nativefd = checkAndReturnNativeFD();
    // 调用native方法绑定本地地址
    bind0(nativefd, address, port, exclusiveBind);
    // 本地端口
    if (port == 0) {
        localport = localPort0(nativefd);
    } else {
        localport = port;
    }
}

5. 服务器监听连接请求

// ServerSocket
void bind(SocketAddress endpoint, int backlog) {
    // getImpl()触发套接字初始化
    getImpl().bind(epoint.getAddress(), epoint.getPort());
    // 监听连接请求
    getImpl().listen(backlog);
}

// AbstractPlainSocketImpl
void listen(int count) {
    socketListen(count);
}

// DualStackPlainSocketImpl
void socketListen(int backlog) {
    // 套接字文件描述符
    int nativefd = checkAndReturnNativeFD();
    // 调用native方法监听请求
    listen0(nativefd, backlog);
}

6. 客户端请求连接

// Socket
void connect(SocketAddress endpoint, int timeout) {
    // 远程地址和端口
    InetSocketAddress epoint = (InetSocketAddress) endpoint;
    InetAddress addr = epoint.getAddress ();
    int port = epoint.getPort();

    // 连接请求
    impl.connect(addr.getHostName(), port);

    // 已连接
    connected = true;
    // 如果套接字在连接之前没有绑定，内核将选择临时端口和本地地址
    bound = true;
}

// AbstractPlainSocketImpl
void connect(String host, int port){
    InetAddress address = InetAddress.getByName(host);
    if (address.isAnyLocalAddress()) {
        doConnect(InetAddress.getLocalHost(), port, timeout);
    } else {
        doConnect(address, port, timeout);
    }
}

// AbstractPlainSocketImpl
void doConnect(InetAddress address, int port, int timeout) {
    socketConnect(address, port, timeout);
    if (socket != null) {
        // Socket设置为已绑定、已连接
        socket.setBound();
        socket.setConnected();
    }
}

// DualStackPlainSocketImpl
void socketConnect(InetAddress address, int port, int timeout) {
    //  套接字文件描述符
    int nativefd = checkAndReturnNativeFD();

    int connectResult;
    if (timeout <= 0) {
        // 阻塞直到连接成功
        connectResult = connect0(nativefd, address, port);
    } else {
        // 阻塞，直到连接成功或超时
        configureBlocking(nativefd, false);
        try {
            connectResult = connect0(nativefd, address, port);
            if (connectResult == WOULDBLOCK) {
                // 调用native方法超时等待连接
                waitForConnect(nativefd, timeout);
            }
        } finally {
            configureBlocking(nativefd, true);
        }
    }
}

7. 服务器接受连接

// ServerSocket
public Socket accept() {
    Socket s = new Socket((SocketImpl) null);
    implAccept(s);
    return s;
}

// ServerSocket
void implAccept(Socket s) {
    SocketImpl si = null;

    // 创建SocketImpl实例
    s.setImpl();
    
    si = s.impl;
    s.impl = null;
    si.address = new InetAddress();
    si.fd = new FileDescriptor();

    getImpl().accept(si);
    
    s.impl = si;
    s.connected = true;
    s.created = true;
    s.bound = true;
}

// AbstractPlainSocketImpl
void accept(SocketImpl s) {
    socketAccept(s);
}

// DualStackPlainSocketImpl
void socketAccept(SocketImpl s) {
    // ServerSocket监听的文件描述符
    int nativefd = checkAndReturnNativeFD();

    // 与客户端连接的文件描述符
    // 如果复用监听fd，则只能与一个客户端连接通信
    // 为连接新建fd，使服务器能够连接多个客户端
    int newfd = -1;
    // 保存客户端的地址和端口
    InetSocketAddress[] isaa = new InetSocketAddress[1];
    
    if (timeout <= 0) {
        // 调用本地方法与客户端建立连接
        newfd = accept0(nativefd, isaa);
    } else {
        // 超时连接
        configureBlocking(nativefd, false);
        try {
            waitForNewConnection(nativefd, timeout);
            newfd = accept0(nativefd, isaa);
            if (newfd != -1) {
                configureBlocking(newfd, true);
            }
        } finally {
            configureBlocking(nativefd, true);
        }
    }
    
    // 将新SocketImpl的fd设置为连接的文件描述符
    // 使用该fd与客户端进行通信
    fdAccess.set(s.fd, newfd);
    
    // 远程，即客户端的地址和端口
    InetSocketAddress isa = isaa[0];
    s.port = isa.getPort();
    s.address = isa.getAddress();
    // 新SocketImpl的本地端口即ServerSocket监听的端口
    s.localport = localport;
}

8. 通信的InputStream和OutputStream

// Socket
InputStream getInputStream() {
    return impl.getInputStream();
}
OutputStream getOutputStream() {
    return impl.getOutputStream();
}

// AbstractPlainSocketImpl
InputStream getInputStream() {
    socketInputStream = new SocketInputStream(this);
    return socketInputStream;
}
OutputStream getOutputStream() {
    socketOutputStream = new SocketOutputStream(this);
    return socketOutputStream;
}

• SocketInputStream extends FileInputStream

// 指向连接的文件描述符
FileDescriptor fd;
// 指向连接的真正套接字
AbstractPlainSocketImpl impl;
// 指向连接的Socket实例
Socket socket = null;

SocketInputStream(AbstractPlainSocketImpl impl) {
    fd = impl.getFileDescriptor();
    this.impl = impl;
    socket = impl.getSocket();
}

int read(byte b[], int off, int length, int timeout) {
    int n = socketRead(fd, b, off, length, timeout);
}

private int socketRead(FileDescriptor fd, byte b[], int off, int len, int timeout) {
    // 使用套接字接受原语读取
    return socketRead0(fd, b, off, len, timeout);
}

// 流的关闭会导致Socket关闭
public void close() {
    if (socket != null) {
        if (!socket.isClosed()) {
            socket.close();
        }
    } else {
        impl.close();
    }
}

• SocketOutputStream extends FileOutputStream

// 指向连接的文件描述符
FileDescriptor fd;
// 指向连接的真正套接字
AbstractPlainSocketImpl impl;
// 指向连接的Socket实例
Socket socket = null;

SocketOutputStream(AbstractPlainSocketImpl impl) {
    fd = impl.getFileDescriptor();
    this.impl = impl;
    socket = impl.getSocket();
}

void write(int b) {
    temp[0] = (byte)b;
    socketWrite(temp, 0, 1);
}

void socketWrite(byte b[], int off, int len) {
    // 写到套接字
    socketWrite0(fd, b, off, len);
}

// 流的关闭会导致Socket关闭
public void close() {
    if (socket != null) {
        if (!socket.isClosed()) {
            socket.close();
        }
    } else {
        impl.close();
    }
}

• shutdownInput()和shutdownOutput()

// Socket
void shutdownInput() {
    getImpl().shutdownInput();
    shutIn = true;
}
void shutdownOutput() {
    getImpl().shutdownOutput();
    shutOut = true;
}

// AbstractPlainSocketImpl
protected void shutdownInput() throws IOException {
    if (fd != null) {
        // SHUT_RD = 0
        socketShutdown(SHUT_RD);
        if (socketInputStream != null) {
            socketInputStream.setEOF(true);
        }
      shut_rd = true;
    }
}
protected void shutdownOutput() {
    if (fd != null) {
        // SHUT_WR = 1
        socketShutdown(SHUT_WR);
        shut_wr = true;
    }
}

// DualStackPlainSocketImpl
// howto：0，input；1，output；
void socketShutdown(int howto) throws IOException {
    int nativefd = checkAndReturnNativeFD();
    shutdown0(nativefd, howto);
}

9. 关闭

// ServerSocket/Socket
public void close() {
    synchronized(closeLock) {
        if (isClosed())
            return;
        if (created)
            impl.close();
        closed = true;
    }
}

// AbstractPlainSocketImpl
protected void close() throws IOException {
    synchronized(fdLock) {
        if (fd != null) {
            if (fdUseCount == 0) {
                if (closePending) {
                    return;
                }
                closePending = true;
                // 我们分两步关闭文件描述符——首先是“预关闭”，它关闭套接字，但不释放底层文件描述符。
                // 由于未传输数据和长时间的逗留间隔，此操作可能很长。
                // 一旦预关闭完成，我们做实际的套接字来释放fd。
                try {
                    socketPreClose();
                } finally {
                    socketClose();
                }
                fd = null;
                return;
                
            } else {
                // 还需要递减fdUseCount来通知释放fd的最后一个线程关闭它。
                if (!closePending) {
                    closePending = true;
                    fdUseCount--;
                    socketPreClose();
                }
            }
        }
    }
}
void socketPreClose() {
    socketClose0(true);
}
void socketClose() {
    socketClose0(false);
}

// DualStackPlainSocketImpl
void socketClose0(boolean useDeferredClose/*unused*/) throws IOException {
    final int nativefd = fdAccess.get(fd);
    fdAccess.set(fd, -1);
    close0(nativefd);
}