​Socket - TCP快速入门

CodeNeil

Socket - TCP 快速入门

TCP 是什么

  • 英语:Transmission Control Protocol,缩写为 TCP。
  • TCP 是传输控制协议;是一种面向连接的、可靠的基于字节流传输层通信协议,由 IETF 的 RFC 793 定义。
  • 与 UDP 一样,完成第四层传输层所指定的功能与职责。
  • 和 UDP 最大的区别是需要连接的,三次握手四次挥手,校验机制保证了数据传输的稳定性和可靠性。

TCP 的机制

  • 三次握手、四次挥手。
  • 具有校验机制、可靠、稳定的数据传输。

TCP连接、传输过程

TCP 能做什么

  1. 聊天消息传输、推送。
  2. 单人语音视频聊天。
  3. 几乎 UDP 能做的都能做,但要考虑复杂性、性能问题。
  4. TCP 无法进行广播多播的操作。
  5. 无法搜索,搜索只能 UDP 来做。

TCP 核心 API 讲解

  • socket() :创建一个客户端 Socket。
  • bind() : 绑定一个 Socket 到一个本地地址和端口上。
  • accept():服务器端接受一个新的连接。
  • write() :把数据写入到 Socket 输出流。
  • read():从 Socket 输入流中读取数据。

客户端创建流程

客户端创建流程

服务端创建流程

服务端创建流程

三次握手、四次挥手

三次握手

  • 第一次握手:客户端发送带有 SYN 标志的连接请求报文段,然后进入 SYN_SEND 状态,等待服务端确认。
  • 第二次握手:服务端接受到客户端的 SYN 报文段后,需要发送 ACK 信息对这个 SYN 报文段进行确认。同时,还要发送自己的 SYN 请求信息。服务端会将上述信息放到一个报文段(SYN+ACK 报文段)中,一并发送给客户端,此时服务端进入 SYN_RECV 状态。
  • 第三次握手:客户端接收到服务端的 SYN+ACK 报文段后,会向服务端发送 ACK 确认报文段,这个报文段发送完毕后,客户端和服务端都进入 ESTABLEISHED 状态,完成 TCP 三次握手。

TCP 三次握手

四次挥手

当被动方收到主动方的 FIN 报文通知时,它仅仅表示主动方没有数据再发送给被动方了。但未必被动方所有的数据都完整的发送给了主动方,所以被动方不会马上关闭 SOCKET,它可能还需要发送一些数据给主动方后,再发送 FIN 报文给主动方,告诉主动方同意关闭连接,所以这里的 ACK 报文和 FIN 报文多数情况下都是分开发送的。

原理:

  1. 第一次挥手:Client 发送一个 FIN,用来关闭 Client 到 Server 的数据传送,Client 进入 FIN_WAIT_1 状态。
  2. 第二次挥手:Server 收到 FIN 后,发送一个 ACK 给 Client,确认序号为收到序号+1(与 SYN 相同,一个 FIN 占用一个序号),Server 进入 CLOSE_WAIT 状态。
  3. 第三次挥手:Server 发送一个 FIN,用来关闭 Server 到 Client 的数据传送,Server 进入 LAST_ACK 状态。
  4. 第四次挥手:Client 收到 FIN 后,Client 进入 TIME_WAIT 状态,接着发送一个 ACK 给 Server,确认序号为收到序号+1,Server 进入 CLOSED 状态,完成四次挥手。

TCP 传输可靠性

  • 校验和

    发送的数据包的二进制相加然后取反,目的是检测数据在传输过程中的任何变化。如果收到报文段的检验和有差错,TCP 将丢弃这个报文段和不确认收到此报文段。

  • 确认应答与序列号

    TCP 给发送的每一个包进行编号,接收方对数据包进行排序,把有序数据传送给应用层。

  • 超时重传

    TCP 发出一个段后,它启动一个定时器,等待目的端确认收到这个报文段。如果不能及时收到一个确认,将重发这个报文段。

  • 流量控制

    TCP 连接的每一方都有固定大小的缓冲空间,TCP 的接收端只允许发送端发送接收端缓冲区能接纳的数据。当接收方来不及处理发送方的数据,能提示发送方降低发送的速率,防止包丢失。TCP 使用的流量控制协议是可变大小的滑动窗口协议。

  • 拥塞控制

    当网络拥塞时,减少数据的发送。

应用数据被分割成 TCP 认为最适合发送的数据块。

TCP 的接收端会丢弃重复的数据

TCP 数据发送流程

TCP数据发送流程

排序、组装流程

由于数据传输的顺序可能是不一定的,所以在此中间会进行排序。

排序、组装流程

数据包丢失,进行重传

数据包丢失,进行重传

连接中断

当连接中断后,需要进行重连、然后重新进行重传。

连接中断

一对多传输流程

一对多传输流程

TCP 基础数据传输案例代码

public class Server {
    private static final int PORT = 20000;

    public static void main(String[] args) throws IOException {
        ServerSocket server = createServerSocket();
        initServerSocket(server);
        // 绑定到本地端口上
        server.bind(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 50);
        System.out.println("服务器准备就绪~");
        System.out.println("服务器信息:" + server.getInetAddress() + " P:" + server.getLocalPort());
        // 等待客户端连接
        for (; ; ) {
            // 得到客户端
            Socket client = server.accept();
            // 客户端构建异步线程
            ClientHandler clientHandler = new ClientHandler(client);
            // 启动线程
            clientHandler.start();
        }

    }

    private static ServerSocket createServerSocket() throws IOException {
        // 创建基础的ServerSocket
        ServerSocket serverSocket = new ServerSocket();
        // 绑定到本地端口20000上,并且设置当前可允许等待链接的队列为50个
        //serverSocket = new ServerSocket(PORT);
        // 等效于上面的方案,队列设置为50个
        //serverSocket = new ServerSocket(PORT, 50);
        // 与上面等同
        // serverSocket = new ServerSocket(PORT, 50, Inet4Address.getLocalHost());
        return serverSocket;
    }

    private static void initServerSocket(ServerSocket serverSocket) throws IOException {
        // 是否复用未完全关闭的地址端口
        serverSocket.setReuseAddress(true);
        // 等效Socket#setReceiveBufferSize
        serverSocket.setReceiveBufferSize(64 * 1024 * 1024);
        // 设置serverSocket#accept超时时间
        // serverSocket.setSoTimeout(2000);
        // 设置性能参数:短链接,延迟,带宽的相对重要性
        serverSocket.setPerformancePreferences(1, 1, 1);
    }

    /**
     * 客户端消息处理
     */
    private static class ClientHandler extends Thread {
        private Socket socket;

        ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            super.run();
            System.out.println("新客户端连接:" + socket.getInetAddress() + " P:" + socket.getPort());
            try {
                // 得到套接字流
                OutputStream outputStream = socket.getOutputStream();
                InputStream inputStream = socket.getInputStream();
                byte[] buffer = new byte[256];
                int readCount = inputStream.read(buffer);
                ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, 0, readCount);
                // byte
                byte be = byteBuffer.get();
                // char
                char c = byteBuffer.getChar();
                // int
                int i = byteBuffer.getInt();
                // bool
                boolean b = byteBuffer.get() == 1;
                // Long
                long l = byteBuffer.getLong();
                // float
                float f = byteBuffer.getFloat();
                // double
                double d = byteBuffer.getDouble();
                // String
                int pos = byteBuffer.position();
                String str = new String(buffer, pos, readCount - pos - 1);
                System.out.println("收到数量:" + readCount + " 数据:" + be + "\n" + c + "\n" + i + "\n" + b + "\n" + l + "\n" + f + "\n" + d + "\n" + str + "\n");
                outputStream.write(buffer, 0, readCount);
                outputStream.close();
                inputStream.close();

            } catch (Exception e) {
                System.out.println("连接异常断开");
            } finally {
                // 连接关闭
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("客户端已退出:" + socket.getInetAddress() + " P:" + socket.getPort());
        }
    }
}
public class Client {
    private static final int PORT = 20000;
    private static final int LOCAL_PORT = 20001;

    public static void main(String[] args) throws IOException {
        Socket socket = createSocket();
        initSocket(socket);
        // 链接到本地20000端口,超时时间3秒,超过则抛出超时异常
        socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 3000);
        System.out.println("已发起服务器连接,并进入后续流程~");
        System.out.println("客户端信息:" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
        System.out.println("服务器信息:" + socket.getInetAddress() + " P:" + socket.getPort());
        try {
            // 发送接收数据
            todo(socket);
        } catch (Exception e) {
            System.out.println("异常关闭");
        }
        // 释放资源
        socket.close();
        System.out.println("客户端已退出~");

    }

    private static Socket createSocket() throws IOException {
        /*
        // 无代理模式,等效于空构造函数
        Socket socket = new Socket(Proxy.NO_PROXY);
        // 新建一份具有HTTP代理的套接字,传输数据将通过www.baidu.com:8080端口转发
        Proxy proxy = new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress(Inet4Address.getByName("www.baidu.com"), 8800));
        socket = new Socket(proxy);
        // 新建一个套接字,并且直接链接到本地20000的服务器上
        socket = new Socket("localhost", PORT);
        // 新建一个套接字,并且直接链接到本地20000的服务器上
        socket = new Socket(Inet4Address.getLocalHost(), PORT);
        // 新建一个套接字,并且直接链接到本地20000的服务器上,并且绑定到本地20001端口上
        socket = new Socket("localhost", PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        socket = new Socket(Inet4Address.getLocalHost(), PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        */
        Socket socket = new Socket();
        // 绑定到本地20001端口
        socket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), LOCAL_PORT));

        return socket;
    }

    private static void initSocket(Socket socket) throws SocketException {
        // 设置读取超时时间为2秒
        socket.setSoTimeout(2000);
        // 是否复用未完全关闭的Socket地址,对于指定bind操作后的套接字有效
        socket.setReuseAddress(true);
        // 是否开启Nagle算法
        socket.setTcpNoDelay(true);
        // 是否需要在长时无数据响应时发送确认数据(类似心跳包),时间大约为2小时
        socket.setKeepAlive(true);
        // 对于close关闭操作行为进行怎样的处理;默认为false,0
        // false、0:默认情况,关闭时立即返回,底层系统接管输出流,将缓冲区内的数据发送完成
        // true、0:关闭时立即返回,缓冲区数据抛弃,直接发送RST结束命令到对方,并无需经过2MSL等待
        // true、200:关闭时最长阻塞200毫秒,随后按第二情况处理
        socket.setSoLinger(true, 20);
        // 是否让紧急数据内敛,默认false;紧急数据通过 socket.sendUrgentData(1);发送
        socket.setOOBInline(true);
        // 设置接收发送缓冲器大小
        socket.setReceiveBufferSize(64 * 1024 * 1024);
        socket.setSendBufferSize(64 * 1024 * 1024);
        // 设置性能参数:短链接,延迟,带宽的相对重要性
        socket.setPerformancePreferences(1, 1, 0);
    }

    private static void todo(Socket client) throws IOException {
        // 得到Socket输出流
        OutputStream outputStream = client.getOutputStream();
        // 得到Socket输入流
        InputStream inputStream = client.getInputStream();
        byte[] buffer = new byte[256];
        ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
        // byte
        byteBuffer.put((byte) 126);
        // char
        char c = 'a';
        byteBuffer.putChar(c);
        // int
        int i = 2323123;
        byteBuffer.putInt(i);
        // bool
        boolean b = true;
        byteBuffer.put(b ? (byte) 1 : (byte) 0);
        // Long
        long l = 298789739;
        byteBuffer.putLong(l);
        // float
        float f = 12.345f;
        byteBuffer.putFloat(f);
        // double
        double d = 13.31241248782973;
        byteBuffer.putDouble(d);
        // String
        String str = "Hello你好!";
        byteBuffer.put(str.getBytes());
        // 发送到服务器
        outputStream.write(buffer, 0, byteBuffer.position() + 1);
        // 接收服务器返回
        int read = inputStream.read(buffer);
        System.out.println("收到数量:" + read);
        // 资源释放
        outputStream.close();
        inputStream.close();
    }
}
阅读 187

Java菜鸟程序员
Be a good developer .微信公众号:Java菜鸟程序员

codeing.....

532 声望
301 粉丝
0 条评论

codeing.....

532 声望
301 粉丝
宣传栏