Netty--从内核角度出发讲解BIO

最新推荐文章于 2024-02-26 10:00:00 发布
最新推荐文章于 2024-02-26 10:00:00 发布
阅读量164 收藏 1
点赞数
文章标签： linux netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40616823/article/details/109395725
版权
一、Socket的连接过程、TCP的一些参数

  • 前置知识
    用到的命令
    netstat -natp 查看网络连接和占用的端口
    tcpdump -nn -i eth0 port 9090开监听抓取数据包
    lsof -p <进程号> 查看某个进程已经打开的文件状态

  • Socket服务端代码

package com.haizhang.netty.bio;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;


public class SocketIOPropertites {
    //server socket listen property: 这些配置不是JVM层级的，是关联到内核的TCP协议栈的一些选项参数。
    private static final int RECEIVE_BUFFER = 10;
    private static final int SO_TIMEOUT = 0;  // 服务端的超时时间
    private static final boolean REUSE_ADDR = false;
    private static final int BACK_LOG = 2; // 多少个连接可以被积压
    //client socket listen property on server endpoint:
    private static final boolean CLI_KEEPALIVE = false;
    private static final boolean CLI_OOB = false;
    private static final int CLI_REC_BUF = 20;
    private static final boolean CLI_REUSE_ADDR = false;
    private static final int CLI_SEND_BUF = 20;
    private static final boolean CLI_LINGER = true;
    private static final int CLI_LINGER_N = 0;
    private static final int CLI_TIMEOUT = 0;  // 客户端的超时时间
    private static final boolean CLI_NO_DELAY = false;
    /*

        StandardSocketOptions.TCP_NODELAY
        StandardSocketOptions.SO_KEEPALIVE
        StandardSocketOptions.SO_LINGER
        StandardSocketOptions.SO_RCVBUF
        StandardSocketOptions.SO_SNDBUF
        StandardSocketOptions.SO_REUSEADDR
     */
    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            server = new ServerSocket();
            server.bind(new InetSocketAddress(9090), BACK_LOG);
            server.setReceiveBufferSize(RECEIVE_BUFFER);
            server.setReuseAddress(REUSE_ADDR);
            server.setSoTimeout(SO_TIMEOUT);

        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("server up use 9090!");
        try {
            while (true) {
                // System.in.read();  //分水岭：
                final Socket client = server.accept();  //阻塞1，没有 -1  一直卡着不动  accept(4,
                System.out.println("client port: " + client.getPort());
                client.setKeepAlive(CLI_KEEPALIVE);
                client.setOOBInline(CLI_OOB);
                client.setReceiveBufferSize(CLI_REC_BUF);
                client.setReuseAddress(CLI_REUSE_ADDR);
                client.setSendBufferSize(CLI_SEND_BUF);
                client.setSoLinger(CLI_LINGER, CLI_LINGER_N);
                client.setSoTimeout(CLI_TIMEOUT);
                client.setTcpNoDelay(CLI_NO_DELAY);
                //client.read   //阻塞   没有  -1 0
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            InputStream in = client.getInputStream(); //阻塞2
                            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                            char[] data = new char[1024];
                            while (true) {

                                int num = reader.read(data);

                                if (num > 0) {
                                    System.out.println("client read some data is :" + num + " val :" + new String(data, 0, num));
                                } else if (num == 0) {
                                    System.out.println("client readed nothing!");
                                    continue;
                                } else {
                                    System.out.println("client readed -1...");
                                    System.in.read();
                                    client.close();
                                    break;
                                }
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端代码

package com.bjmashibing.system.io;

import java.io.*;
import java.net.Socket;

public class SocketClient {

    public static void main(String[] args) {
        try {
            Socket client = new Socket("192.168.150.11",9090);

            client.setSendBufferSize(20);
            client.setTcpNoDelay(true);  // 如果数据量比较小，会不会积攒起来再发，默认是true
            client.setOOBInLine(true);
            OutputStream out = client.getOutputStream();

            InputStream in = System.in;
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));

            while(true){
                String line = reader.readLine();
                if(line != null ){
                    byte[] bb = line.getBytes();
                    for (byte b : bb) {
                        out.write(b);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

下面详细跟踪建立连接的过程
启动服务端
在这里插入图片描述
开启服务端后，出现了一个对于 9090 的 listen 状态。
TCP 三次握手是走 listen 的，建立连接之后，后面走文件描述符，那就是另外一个环节了，我们后面再讲。
在这里插入图片描述
使用jps得到服务端的进程id号：7932
在这里插入图片描述
使用lsof -p 7932查看7932端口的文件描述符的分配情况。

在这里插入图片描述

参数详解：
COMMAND：进程的名称
PID：进程标识符
USER：进程所有者
FD：文件描述符，应用程序通过文件描述符识别该文件。如cwd、txt等
TYPE：文件类型，如DIR、REG等
DEVICE：指定磁盘的名称
SIZE：文件的大小
NODE：索引节点（文件在磁盘上的标识）
NAME：打开文件的确切名称
FD列中的文件描述符：
cwd值表示应用程序的当前工作目录，这是该应用程序启动的目录，除非它本身对这个目录进行更改,txt类型的文件是程序代码，如应用程序二进制文件本身或共享库，如上列表中显示的/sbin/init程序。其次数值表示应用程序的文件描述符，这是打开该文件时返回的一个整数。如上的最后一行文件/dev/initctl，其文件描述符为 10。
u 表示该文件被打开并处于读取/写入模式，而不是只读 ? 或只写 (w) 模式。同时还有大写 的W 表示该应用程序具有对整个文件的写锁。该文件描述符用于确保每次只能打开一个应用程序实例。初始打开每个应用程序时，都具有三个文件描述符，从0到2，分别表示标准输入、输出和错误流。所以大多数应用程序所打开的文件的FD都是从3开始。
Type列：
文件和目录分别称为REG和DIR。
CHR表示字符;(fopen，打开文件)
BLK表示块设备；
UNIX、FIFO和IPv4，分别表示UNIX 域套接字、先进先出(FIFO)队列和网际协议(IP)套接字。
FIFO表示先进先出；（popen，pipe）
inet表示网际协议(IP)套接字tcp/udp;(socket)
netlink表示netlink

启动客户端
客户端启动，进入代码的阻塞等待用户输入逻辑
在这里插入图片描述
开启监听之后，我们使用nc命令，连接本地的9090端口

[root@node1 ~]# nc localhost 9090

nc命令介绍https://blog.youkuaiyun.com/u012486730/article/details/82019996

在服务端抓到了三次握手的包
在这里插入图片描述
在服务端看到建立了连接，虽然连接还未被使用。
在这里插入图片描述
在客户端进行用户输入之后（服务端也有的阻塞的逻辑，需要回车才能接收client的数据）

在这里插入图片描述
继续查看服务端抓包监听在这里插入图片描述
查看服务端的连接状态：双方开辟了资源。即便你程序不要我，我也在内核里有资源用来接收或者等待一类的。

netstat -antp  | head -n 2 ;netstat -antp | grep 9090

在这里插入图片描述
服务端输入回车之后
接受到了客户端发过来的数据
在这里插入图片描述
刚才的socket连接已经被分配给7932了
在这里插入图片描述
lsof 得到了新的文件描述符 6
总结一下
TCP：面向连接的，可靠的传输协议
在这里插入图片描述
Socket：是一个四元组。ip:port ip:port四元组的任何一个元的不同，都可以区分不同的连接。

面试题 1：服务端80端口接收客户端连接之后，是否需要为客户端的连接分配一个随机端口号？
答：不需要。

面试题 2：现在，有一个客户端，有一个服务端，
客户端的ip地址是AIP，程序使用端口号CPORT想要建立连接。
服务端的IP地址是XIP，端口号是XPORT。
现在假设某一个客户端A开了很多连接占满了自己的65535个端口号，那客户端A是否还能与另一个服务端建立建立连接？
答：可以，因为只要能保证四元组唯一即可

在这里插入图片描述
注：一台服务器是可以与超过65535个客户端保持长连接的，调优到超过百万连接都没问题，只要四元组唯一就可以了。客户端来了之后，服务端是不需要单独给它开辟一个端口号的。
在这里插入图片描述
下面这个图可以说明，无论再多的连接，服务端始终是使用的同一个ip:端口
在这里插入图片描述
那么，我们常见的报错“端口号被占用”是什么原因？

我们常见的报错“端口号被占用”实际上是在启动SocketSocket的时候，而不是Socket，两者不是一个概念。如果两个服务使用了相同的端口号，这时如果来了一个数据包，内核无法区分是哪一个服务在LISTEN，不知道要发给哪一个服务了，如下图例子
在这里插入图片描述
在这里插入图片描述
每一个独立的进程只要维护它自己的文件描述符唯一即可。
在这里插入图片描述
keepalive
三个不同层级的 keepalive

  • TCP协议中规定，如果双方建立的连接（虚无的，并不是物理的连接），如果双方很久都不说话，你能确定对方还活着吗？不能，因为可能突然断电。所以规定了这么一种机制，哪怕是周期性的消耗一些网络资源，也要及时把无效的连接踢掉，节省内存。
  • HTTP级别
  • 负载均衡keepalived

网络IO的变化 演进模型（BIO）
一句话概括BIO？
BIO就是，客户端来一个连接，抛出一个线程，来一个连接，抛出一个线程…
BIO存在两个方面的阻塞，第一个方面就是ServerSocket在开启监听端口后accept客户端等待连接时，会阻塞当前线程。第二个就是，当ServerSocket接受到客户端连接时，后续要阻塞的等待客户端读数据的操作。
几个维度
同步、异步、阻塞、非阻塞
用到的命令：
strace -ff -o out /usr/java TestSocket
用来追踪Java程序和内核进行了哪些交互（进行了哪些系统调用）

strace -e strace=内核函数 -p pid 可以指定strace只追踪某个内核调用事件。参考strace用法介绍

详细追踪 BIO 的连接过程

public class TestServer {
    //server socket listen property: 这些配置不是JVM层级的，是关联到内核的TCP协议栈的一些选项参数。
    private static final int RECEIVE_BUFFER = 10;
    private static final int SO_TIMEOUT = 0;  // 服务端的超时时间
    private static final boolean REUSE_ADDR = false;
    private static final int BACK_LOG = 2; // 多少个连接可以被积压
    //client socket listen property on server endpoint:
    private static final boolean CLI_KEEPALIVE = false;
    private static final boolean CLI_OOB = false;
    private static final int CLI_REC_BUF = 20;
    private static final boolean CLI_REUSE_ADDR = false;
    private static final int CLI_SEND_BUF = 20;
    private static final boolean CLI_LINGER = true;
    private static final int CLI_LINGER_N = 0;
    private static final int CLI_TIMEOUT = 0;  // 客户端的超时时间
    private static final boolean CLI_NO_DELAY = false;
    /*

        StandardSocketOptions.TCP_NODELAY
        StandardSocketOptions.SO_KEEPALIVE
        StandardSocketOptions.SO_LINGER
        StandardSocketOptions.SO_RCVBUF
        StandardSocketOptions.SO_SNDBUF
        StandardSocketOptions.SO_REUSEADDR
     */
    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            server = new ServerSocket();
            server.bind(new InetSocketAddress(8090), BACK_LOG);
            server.setReceiveBufferSize(RECEIVE_BUFFER);
            server.setReuseAddress(REUSE_ADDR);
            server.setSoTimeout(SO_TIMEOUT);

        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("server up use 8090!");
        try {
            while (true) {
                // System.in.read();  //分水岭：
                final Socket client = server.accept();  //阻塞1，没有 -1  一直卡着不动  accept(4,
                System.out.println("client port: " + client.getPort());
                client.setKeepAlive(CLI_KEEPALIVE);
                client.setOOBInline(CLI_OOB);
                client.setReceiveBufferSize(CLI_REC_BUF);
                client.setReuseAddress(CLI_REUSE_ADDR);
                client.setSendBufferSize(CLI_SEND_BUF);
                client.setSoLinger(CLI_LINGER, CLI_LINGER_N);
                client.setSoTimeout(CLI_TIMEOUT);
                client.setTcpNoDelay(CLI_NO_DELAY);
                //client.read   //阻塞   没有  -1 0
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            InputStream in = client.getInputStream(); //阻塞2
                            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                            while (true) {
                                System.out.println(reader.readLine());
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

上面的代码使用jdk1.4跑起来
在这里插入图片描述

我们需要安装低版本的jdk才可以看清楚Socket连接时发生的详细细节，这里需要安装j2sdk-1_4_2_18-linux-i586.bin
参考https://blog.youkuaiyun.com/developerof/article/details/38455399

注意，如果是64位的机器，会报异常 bad ELF interpreter问题 ，解决办法:
情况一：64位系统中安装了32位程序解决办法
是因为64位系统中安装了32位程序
解决方法：

yum install glibc.i686

情况二：解决交叉编译环境错误

# arm-linux-gcc hello.c -o tt
/home/gl/usr/local/arm/4.3.2/bin/arm-linux-gcc: /home/gl/usr/local/arm/4.3.2/bin/arm-none-linux-gnueabi-gcc: /lib/ld-linux.so.2: bad ELF interpreter: 没有那个文件或目录
/home/gl/usr/local/arm/4.3.2/bin/arm-linux-gcc:行3: /home/gl/usr/local/arm/4.3.2/bin/arm-none-linux-gnueabi-gcc: 成功
[root@austgl gl]# yum install ld-linux.so.2

在服务端用jps找到进程的id号是8384
在这里插入图片描述

在服务端使用tail监控out.8384文件的输出（8384是main线程的输出，其他的out可能是一些垃圾回收线程等其他线程的输出）
（这里注意一下一共有8个线程，待会儿建立连接之后再看）
在这里插入图片描述
可以看到JVM用到了内核系统调用的accept，main线程正在阻塞
在这里插入图片描述
注意上面的accept后面紧跟着一个数字3，linux内核为每个进程提供了一个文件描述符表，而文件描述符都有自己的编号，0表示标准输入、1表示标准输出、2表示标准错误输出。故此这里打开一个Socket端口，会调用linux内核生成一个文件描述符，并产生一个编号为3的文件描述符编号。

紧着这，在一个客户端上建立一个连接
在这里插入图片描述
在服务端我们看到，刚才阻塞accept(3,的位置继续执行。34178是客户端连接进来的随机端口号，192.1618.150.12是来自于客户端的ip地址
在这里插入图片描述
当我们客户端连上的时候，会生成一个线程，那么线程究竟在操作系统中是怎么生成的呢？可以关注到accept(3，执行后，内核实际上调用了clone：
clone是linux的一个系统调用。Java当中的一个线程，就是操作系统的一个子线程。下图我们看到，（客户端连接进来之后），服务端调用clone函数，开启了一个线程号为8447的新线程。flags里面记录的是子线程共享的文件系统、打开的文件等父线程的系统资源。
在这里插入图片描述
在clone之前，还会有一个系统调用指令mmap2,它负责将文件和设备映射到内存。mmap2系统调用使得使用32位off_t的应用程序能够映射大文件(最多2^44字节)。

参考https://man7.org/linux/man-pages/man2/mmap2.2.html

查看用strace输出的out文件，也可以证明8447这个新线程的存在。
在这里插入图片描述
在服务端可以看到，多了一个文件描述符5，表示的是从node01(服务端机器名称)到node02(客户端机器名称)的已连通的状态（socket四元组）
在这里插入图片描述
服务端 8447.out 正在recv阻塞接收
在这里插入图片描述

想学好Linux，去学习文档中这些man帮助手册，有时候比网络上的博客文章更准确（也可以 man man 查看帮助文档本身的帮助文档）
使用man 2 socket，你会发现所谓socket系统调用，其实就是调用了一个有返回值（文件描述符）的函数（用于LISTEN）
在这里插入图片描述

稍稍总结一下
BIO 模型的整个连接过程
无论哪种IO模型，application想要和外界通信，都要进行上面所展示的一系列的（3步）系统调用，都是不可缺少的。
之后服务端进入阻塞状态accept(3,等待客户端的连接。此次阻塞被成功地连接之后，又进入一的新的阻塞，等待新的客户端连接。
一旦连接成功之后，会为这个连接抛出去一个新的线程，新的线程中又进入一个阻塞状态recv(5,等待接收消息。
在这里插入图片描述

qq_2368521029
关注
Netty-Reactor模型常见知识点小结
禅与计算机程序设计的艺术
08-27 992
笔者分别带入索引0、5、8，进行与运算时，真正参与的二进制永远是和永远是7以内的进制，得出的结果分别是0、5、0，永远不会越界，并且运算性能还能得到保证。这样可以在进行IO操作时立即返回，不会阻塞线程，提高系统的并发性和响应性能。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。进行具体的事件处理。
Netty中的Reactor模型实现
最新发布
u013771019的专栏
06-17 430
其中Linux kernel 在5.1版本引入的异步IO库io_uring正在netty中孵化。有着不同的实现，我们只需要切换不同的实现类就可以完成对Netty。比如Linux 2.6版本以上用的是。根据操作系统以及版本的不同选择对应的。Netty版本：4.1.17。，2.6版本以下用的是。IO多路复用技术实现。
网络与IO知识扫盲（三）：从系统调用的角度，剖析 Socket 的连接过程、BIO 的连接过程
热门推荐
寒泉
06-16 6万+
前置知识 用到的命令 netstat -natp 查看网络连接和占用的端口 tcpdump -nn -i eth0 port 9090 开监听抓取数据包 lsof -p <进程号>查看某个进程已经打开的文件状态 Socket 服务端代码 package com.bjmashibing.system.io; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import j
java之socket编程（BIO）
我想月薪过万的博客
08-20 360
效果展示 原理分析 BIO： 即阻塞型 IO 操作 因为我们的代码中有 阻塞操作的api -》 accept() 、read() 代码展示 package BIO; import java.io.FileOutputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.Arrays; /** * ClassName: Socke
网络编程- Socket-BIO
qq_31142237的博客
05-30 299
网络编程- Scoket-BIO 上图时对socket做一个简单介绍, 具体的实现这里就说了。主要将一下java网络编程几大IO模型实现、原理、演变，IO模型分别为BIO、OS级别的NIO(NONBLOCKING IO)、NIO java jdk1.4升级的NEW IO。 BIO模型 前提知识：想要彻底的了解IO模型及其原理和演变，你需要了解一下操作系统底层相关的一些系统调用知识，我上篇文章介绍过了，参考学习，有错误的望指出。系统调用|内核程序 想必大家都知道IO操作肯定需要系统调用的，因为网络传输势必会
socket编程 - 演化过程之BIO(blocking IO)
猛犸象
05-17 624
在学习socket编程之前，先要了解TCP通讯，因为我们常用的服务器都是基于TCP协议的。 关于TCP的详细解释 https://blog.youkuaiyun.com/raoxiaoya/article/details/106113128 最开始的时候socket之间的通讯都是阻塞的，比如 socket_accept, socket_read函数都会阻塞进程，这使得服务端的并发能力很低。其流程图如下： 对于BIO模式已经没人用了，就不做过多说明。 PHP服务端示例代码 https://gitee.com/phpr
Linux系统调用
Linux知识积累
06-01 262
什么是系统调用?Linux内核中设置了一组用于实现各种系统功能的子程序，称为系统调用。用户可以通过系统调用命令在自己的应用程序中调用它们。从某种角度来看，系统调用和普通的...
深入讲解Netty那些事儿之从内核角度看IO模型（上）
youzhangjing_的博客
12-01 533
当我们熟悉了select的原理后，就很容易理解内核给我们提供的select API了。从select API中我们可以看到，select系统调用是在规定的超时时间内，监听（轮询）用户感兴趣的文件描述符集合上的可读,可写,异常三类事件。select传递给内核监听的文件描述符集合中数值最大的文件描述符+1，目的是用于限定内核遍历范围。select监听的文件描述符集合为，那么maxfdp1的值为5。对可读事件感兴趣的文件描述符集合。对可写事件感兴趣的文件描述符集合。对异常事件感兴趣的文件描述符集合。这里的。
Netty学习——基础篇1（同步阻塞IO-BIO）
geminigoth的博客
02-26 1043
阻塞I/O模型：最常用的I/O模型就是阻塞I/O模型，缺省情况下，所有文件操作都是阻塞的。以套接字接口为例来讲解此模型：在进程空间中调用recvfrom，其系统调用直到数据包到达且被复制到应用进程的缓冲区或者发生错误时才返回，再次期间一直会等待，进程在从调用recvfrom开始到它返回的整段时间内都是被阻塞的，因此成为阻塞I/O模型模型。如下图所示：非阻塞I/O模型：r。
马士兵教育周老师透彻的讲 Socket最简单的示例解析(接受数据，直到有一个回车，客户端就断开了)------目标netty---step0
狗剩的专栏
09-18 445
看懂此块内容来自周老师的视频，具体视频地址找不到了，毕竟是白嫖周老师的视频，没有买会员 这块也不用视频， 记住两个 阻塞就可以了 serverSocket.accept(); // 此处阻塞， 直到有客户端连接 bufferedReader.readLine(); //此处阻塞 ，直到客户端输入****回车 另外要学习调试 windows 版本的调试 使用 网络调试助手 软件 linux 版本 nc 命令调试 package com.tiza.leo.BIO; import jav
搭一套Socket.io 服务只需这几步
yiqiu1959的博客
12-08 4719
Websocket是HTML5新增的一种全双工通信协议，客户端和服务端基于TCP握手连接成功后，两者之间就可以建立持久性的连接，实现双向数据传输。Socket.io不是Websocket，它只是将Websocket和轮询 （Polling）机制以及其它的实时通信方式封装成了通用的接口，并且在服务端实现了这些实时机制的相应代码。也就是说，Websocket仅仅是 Socket.io实现实时通信的一个子集。因此Websocket客户端连接不上Socket.io服务端，当然Socket.io客户端也连接不上Web
深入理解socket——在本地实现一次收发网络包
weixin_45627369的博客
05-29 1517
1. 怎样在本地实现一次收发网络包 ipconfig查看本地ip 适配器（即网卡）：实现网络接口层协议的硬件和软件 主要功能： 对数据进行串/并传输转换； 对数据进行缓存； 实现以太网协议； 过滤功能； 同时能够实现帧的传送和接收，对帧进行封装等。 这里前两个是VMware的虚拟网卡，第三个是真实的网卡 得到本地ip为10.118.145.166 ...
什么是socket
weixin_45193103的博客
03-12 596
什么是socket：套接字，插座和插头的关系。 套接字是四元组组成：源ip+port 目ip+port 表示绝对唯一的连接 绝对唯一：在哪连接是确定的 port：65535个端口号 服务端：会开一个端口号先占着 客户端：不会事先开一个端口号 建立连接的例子：IPA：0 IPB：80 IPA：1 IPB：80 这样最多只能建立65535个连接 IPA：0 IPB：8080 //如果服务器的端口号变了又能建立65535个连接 IPA：0 IPC：8080 //如果另一个端口号和之...
Nextjs使用socket.io创建连接
宏斌的博客
11-02 1182
此情况只会在项目不部署后第一位访问的用户的客户端出现之后的用户访问socket已经创建完毕，想要避免可以在请求之前手动触发服务,例如发送一个请求。因为是服务端被动的创建socket连接所以第一次socket连接会失败这时服务端会创建socket连接，客户端经过短暂时间后下次轮询就会连接成功。如果使用typescript使用新的类型将socket添加。之后就不会在socket连接中失败(正常能够连接的情况下)在请求时创建socket连接。
创建socket.io服务，vue3使用vue-3-socket.io进行连接
ajiejie66的博客
03-24 4950
在ubuntu服务器上创建一个js文件 var app = require('express')(); var http = require('http').Server(app); var io = require('socket.io')(http); app.get('/', function(req, res){ res.send('<h1>这是一个socket服务</h1>'); }); io.on('connection',function(socket) {
iOS使用socketIO实现长连接
知更鸟CoolLee的博客
06-08 1万+
iOS使用socketIO实现长连接
TCP/IP的四元组 五元组 七元组
AAA821的专栏
07-24 9856
四元组是：        源IP地址、目的IP地址、源端口、目的端口 五元组是:       源IP地址、目的IP地址、协议号、源端口、目的端口 七元组是:        源IP地址、目的IP地址、协议号、源端口、目的端口，服务类型以及接口索引 协议号:IP是网络层协议，IP头中的协议号用来说明IP报文中承载的是哪种协议,协议号标识上层是什么协议（一般是传输层协议，比如6 TC
netty获取ip和端口
程序猿学社的博客
06-12 1万+
udp协议： 会有一个DatagramPacket datagramPacket对象 InetSocketAddress remoteAddress = datagramPacket.sender(); String ip = remoteAddress.getAddress().getHostAddress(); int port = remoteAddres...
深入分析Hotspot源码及Linux内核下的NIO与Netty线程模型
资源文件为一份详细讲解分析的PDF文档，标题为《深入Hotspot源码与Linux内核理解NIO与Netty线程模型》。该文档内容易于理解，适合希望深入了解Java NIO以及Netty框架内部工作机制的开发者。 在文档中，首先会对Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值