java tcp底层源码分析

TCP服务端实现

 

     //定义服务器端socket并指定监听端口

    ServerSocket serverSocket = new ServerSocket(5937);

    //调用阻塞式方法来获取客户端连接的socket

    Socket socket = serverSocket.accept();

     //获取客户端socket的输入流

    InputStream inputStream =socket.getInputStream();

    //读取客户端socket的输入流的内容并输出

    byte[]buffer = new byte[512];

    inttemp;

    while((temp = inputStream.read(buffer)) != -1) {

         System.out.println(new String(buffer, 0, temp));

    }

 

TCP客户端实现

 

     //产生socket对象，制定服务器地址和服务器监听的端口号

    Socket socket = new Socket("127.0.0.1", 5937);

    //获取socket的输出流

    OutputStream outputStream =socket.getOutputStream();

    //将数据放入输出流中

    outputStream.write(msg.getBytes());

 

 

 

 

 

//定义服务器端socket并指定监听端口

ServerSocket serverSocket = new ServerSocket(5937);

//

 

java.net.ServerSocket.java96

 

/**

     * Constructs a new {@code ServerSocket}instance bound to the given {@code localAddress}

     * and {@code port}. The backlog is set to{@code backlog}.

     * If {@code localAddress == null}, the ANYaddress is used.

     * If {@code port == 0}, a port will beassigned by the OS.

     *

     * @throws IOException if an error occurs while creating the socket.

     */

public ServerSocket(int port, intbacklog, InetAddress localAddress) throwsIOException {

        checkListen(port);

        this.impl = factory != null ? factory.createSocketImpl()

                : new PlainServerSocketImpl();

        InetAddress addr = (localAddress == null) ? Inet4Address.ANY: localAddress;

 

        synchronized (this) {

            impl.create(true);

            try {

                impl.bind(addr,port);

                readBackBindState();

                impl.listen(backlog> 0 ? backlog : DEFAULT_BACKLOG);

            } catch (IOException e) {

                close();

                throw e;

            }

        }

    }

 

 

//

java:

FileDescriptor fd;

c++:

int fd;

 

int fd =jniGetFDFromFileDescriptor(env, javaFd);

定义：JNIHelp.cpp 320

 

FileDescriptor javaFd =jniCreateFileDescriptor(env, fd);

定义：JNIHelp.cpp 309

//

 

 

 

1.impl.create(true):

//

 

libcore.io.IoBridge.java606

 

public static FileDescriptor socket(boolean stream)

 

FileDescriptor fd;

fd = Libcore.os.socket(AF_INET6, stream ? SOCK_STREAM : SOCK_DGRAM, 0);

 

(stream : true)

 

获得远端fd

 

→

 

libcore_io_posix.cpp 1419

 

static jobject Posix_socket(JNIEnv* env,jobject, jint domain, jint type, jint protocol)

 

socket(domain, type,protocol)

 

//

 

libcore.io.IoBridge.java376

 

 

private static voidsetSocketOptionErrno(FileDescriptor fd, int option, Object value)

 

Libcore.os.setsockoptInt(fd, SOL_SOCKET, SO_REUSEADDR, booleanToInt((Boolean) value));

 

(value : Boolean.TRUE)

(booleanToInt((Boolean)value) : 1)

 

→

 

libcore_io_posix.cpp 1297

 

static void Posix_setsockoptInt(JNIEnv* env, jobject, jobject javaFd, jintlevel, jint option, jint value)

 

setsockopt(fd, level,option, &value, sizeof(value)))

 

 

//

 

2.impl.bind(addr, port):

 

libcore.io.IoBridge.java79

 

public static void bind(FileDescriptor fd,InetAddress address, int port)

 

Libcore.os.bind(fd, address, port);

 

→

 

libcore_io_posix.cpp 486

 

static void Posix_bind(JNIEnv* env, jobject, jobject javaFd, jobjectjavaAddress, jint port)

 

NET_FAIURE_RETRY(env, int, bind, javaFd, sa, sa_len);

宏定义：

bind(javaFd, sa, sa_len);

 

sa：

sockaddr_storage ss;

socklen_t sa_len;

inetAddressToSockaddr(env,javaAddress, port, ss, sa_len)；

const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss);

 

//

3.readBackBindState()：

 

InetAddress localAddress；

localAddress = IoBridge.getSocketLocalAddress(impl.fd);

获得本地IP端口

 

libcore.io.IoBridge.java627

 

public static InetAddress getSocketLocalAddress(FileDescriptor fd)

 

SocketAddress sa =Libcore.os.getsockname(fd);

 

→

 

libcore_io_posix.cpp 409

 

static jobject doGetSockName(JNIEnv* env,jobject javaFd, bool is_sockname)

 

 

sockaddr_storage ss;

sockaddr* sa = reinterpret_cast<sockaddr*>(&ss);

socklen_t byteCount = sizeof(ss);

 

getsockname(fd, sa,&byteCount)

 

 

//

 

4.impl.listen(backlog > 0 ? backlog : DEFAULT_BACKLOG):

 

java.net.PlainSocketImpl.java271

 

protected void listen(int backlog)

 

Libcore.os.listen(fd,backlog);

 

→

 

libcore_io_posix.cpp 965

 

static void Posix_listen(JNIEnv* env, jobject, jobject javaFd, jint backlog)

 

listen(fd, backlog);

 

backlog = DEFAULT_BACKLOG 50

 

 

//

 

//调用阻塞式方法来获取客户端连接的socket

Socket socket = serverSocket.accept();

 

//

 

/**

     * Waits for an incoming request and blocksuntil the connection is opened.

     * This method returns a socket objectrepresenting the just opened

     * connection.

     *

     * @return the connection representing socket.

     * @throws IOException

     *             if an error occurs while acceptinga new connection.

     */

    public Socket accept() throwsIOException {

        checkOpen();

        if(!isBound()) {

            throw new SocketException("Socket is not bound");

        }

 

        Socket aSocket = new Socket();

        try {

            implAccept(aSocket);

        } catch (IOException e) {

            aSocket.close();

            throw e;

        }

        return aSocket;

    }

 

 

 

1.isBound():

 

构造函数中readBackBindState() -> isBound = true;

 

2.implAccept(aSocket):

 

2.1.impl.accept(aSocket.impl)：

 

(java.net.PlainSocketImpl.java80)

 

protected void accept(SocketImpl newImpl)

 

FileDescriptor clientFd =Libcore.os.accept(fd, peerAddress);

newImpl.fd.setInt$(clientFd.getInt$());

newImpl.address = peerAddress.getAddress();

newImpl.port = peerAddress.getPort();

获得对方远端IP端口

 

→

 

(libcore_io_posix.cpp460)

 

static jobject Posix_accept(JNIEnv* env,jobject, jobject javaFd, jobject javaInetSocketAddress)

 

jint clientFd =NET_FAIURE_RETRY(env, int, accept, javaFd, peer,peerLength);

 

宏定义：

 

accept(javaFd, peer,peerLength)

 

peer:

sockaddr_storage ss;

socklen_t sl = sizeof(ss);

memset(&ss, 0, sizeof(ss));

sockaddr* peer =(javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL;

socklen_t* peerLength =(javaInetSocketAddress != NULL) ? &sl : 0;

 

//

 

2.2.aSocket.accepted()：

 

InetAddress localAddress；

localAddress = IoBridge.getSocketLocalAddress(impl.fd);

(获得对方本地IP端口)

 

同上1.3

 

//

 

//获取客户端socket的输入流

InputStream inputStream = socket.getInputStream();

//读取客户端socket的输入流的内容并输出

byte[] buffer= new byte[512];

int temp;

while ((temp = inputStream.read(buffer))!= -1) {

     System.out.println(new String(buffer, 0, temp));

}

 

//

 

@Override protected synchronized InputStream getInputStream() throws IOException {

        checkNotClosed();

        return new PlainSocketInputStream(this);

    }

 

    private static class PlainSocketInputStream extends InputStream {

        private final PlainSocketImpl socketImpl;

 

        public PlainSocketInputStream(PlainSocketImpl socketImpl) {

            this.socketImpl = socketImpl;

        }

 

        @Override public int available() throws IOException {

            return socketImpl.available();

        }

 

        @Override public void close() throws IOException {

            socketImpl.close();

        }

 

        @Override public int read() throws IOException {

            return Streams.readSingleByte(this);

        }

 

        @Override public int read(byte[] buffer, int byteOffset, int byteCount) throws IOException {

            return socketImpl.read(buffer, byteOffset,byteCount);

        }

    }

 

 

 

 

 

/**

     * For PlainSocketInputStream.

     */

    private int read(byte[] buffer, int offset, int byteCount) throwsIOException {

        if(byteCount == 0) {

            return 0;

        }

        Arrays.checkOffsetAndCount(buffer.length, offset, byteCount);

        if(shutdownInput) {

            return -1;

        }

        int readCount = IoBridge.recvfrom(true, fd, buffer, offset, byteCount, 0, null, false);

        // Return of zero bytes for a blocking socket means atimeout occurred

        if(readCount == 0) {

            throw new SocketTimeoutException();

        }

        // Return of -1 indicates the peer was closed

        if(readCount == -1) {

            shutdownInput = true;

        }

        return readCount;

    }

 

 

 

(libcore.io.IoBridge.java549)

 

public static int recvfrom(boolean isRead, FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, DatagramPacket packet, boolean isConnected)

 

result = Libcore.os.recvfrom(fd, bytes, byteOffset, byteCount, flags,srcAddress);

 

→

 

(libcore_io_posix.cpp1185)

 

static jint Posix_recvfromBytes(JNIEnv*env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jintbyteCount, jint flags, jobject javaInetSocketAddress)

 

NET_FAIURE_RETRY(env,ssize_t, recvfrom, javaFd, bytes.get() + byteOffset, byteCount, flags, from, fromLength);

 

宏定义：

 

recvfrom(javaFd,bytes.get() + byteOffset, byteCount, flags, from, fromLength);

 

 

bytes : ScopedBytesRWbytes(env, javaBytes);

byteOffset : 0

flags : 0

from : BULL

fromLength : 0

 

 

问题：

为什么java tcp接收底层代码是recvfrom()而不是read()？