网络IO模型及零拷贝问题

最新推荐文章于 2024-09-12 17:36:02 发布
最新推荐文章于 2024-09-12 17:36:02 发布
阅读量1k 收藏 14
点赞数 26
分类专栏： 计算机网络 操作系统 Linux 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62571233/article/details/140968439
版权

文章目录

BIO

  • 当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来说，很多时候数据在一开始还没有到达。比如，还没有收到一个完整的UDP包。这个时候kernel就要等待足够的数据到来）。这个过程需要等待，也就是说数据被拷贝到操作系统内核的缓冲区中是需要一个过程的。

  • 在用户进程这边，整个进程会被阻塞（当然，是进程自己选择的阻塞）。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。

  • 所以，BIO的特点就是在IO执行的两个阶段都被block了。

  • image.png

image.png

accept监听案例

public class RedisServer
{
    public static void main(String[] args) throws IOException
    {
        byte[] bytes = new byte[1024];

        ServerSocket serverSocket = new ServerSocket(6379);

        while(true)
        {
            System.out.println("-----111 等待连接");
            Socket socket = serverSocket.accept();
            System.out.println("-----222 成功连接");
        }
    }
}

public class RedisClient02
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("------RedisClient02 start");
        Socket socket = new Socket("127.0.0.1", 6379);
    }
}

read案例

public class RedisServerBIO
{
    public static void main(String[] args) throws IOException
    {

        ServerSocket serverSocket = new ServerSocket(6379);

        while(true)
        {
            System.out.println("-----111 等待连接");
            Socket socket = serverSocket.accept();//阻塞1 ,等待客户端连接
            System.out.println("-----222 成功连接");

            InputStream inputStream = socket.getInputStream();
            int length = -1;
            byte[] bytes = new byte[1024];
            System.out.println("-----333 等待读取");
            while((length = inputStream.read(bytes)) != -1)//阻塞2 ,等待客户端发送数据
            {
                System.out.println("-----444 成功读取"+new String(bytes,0,length));
                System.out.println("====================");
                System.out.println();
            }
            inputStream.close();
            socket.close();
        }
    }
}


public class RedisClient01
{
    public static void main(String[] args) throws IOException
    {
        Socket socket = new Socket("127.0.0.1",6379);
        OutputStream outputStream = socket.getOutputStream();
        while(true)
        {
            Scanner scanner = new Scanner(System.in);
            String string = scanner.next();
            if (string.equalsIgnoreCase("quit")) {
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("------input quit keyword to finish......");
        }
        outputStream.close();
        socket.close();
    }
}

上面的模型存在很大的问题，如果客户端与服务端建立了连接，
如果这个连接的客户端迟迟不发数据，程序就会一直堵塞在read()方法上，这样其他客户端也不能进行连接，
也就是一次只能处理一个客户端，对客户很不友好。

利用多线程

只要连接了一个socket，操作系统分配一个线程来处理，这样read()方法堵塞在每个具体线程上而不堵塞主线程，
就能操作多个socket了，哪个线程中的socket有数据，就读哪个socket，各取所需，灵活统一。

public static void main(String[] args) throws IOException
{
    ServerSocket serverSocket = new ServerSocket(6379);
    while(true)
    {
        System.out.println("-----111 等待连接");
        Socket socket = serverSocket.accept();//阻塞1 ,等待客户端连接
        System.out.println("-----222 成功连接");

        new Thread(() -> {
            try {
                InputStream inputStream = socket.getInputStream();
                int length = -1;
                byte[] bytes = new byte[1024];
                System.out.println("-----333 等待读取");
                while((length = inputStream.read(bytes)) != -1)//阻塞2 ,等待客户端发送数据
                {
                    System.out.println("-----444 成功读取"+new String(bytes,0,length));
                    System.out.println("====================");
                    System.out.println();
                }
                inputStream.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        },Thread.currentThread().getName()).start();
    }
}

多线程模型
每来一个客户端，就要开辟一个线程，如果来1万个客户端，那就要开辟1万个线程。
在操作系统中用户态不能直接开辟线程，需要调用内核来创建的一个线程，
这其中还涉及到用户状态的切换（上下文的切换），十分耗资源。

解决方法：
第一个办法：使用线程池
这个在客户端连接少的情况下可以使用，但是用户量大的情况下，你不知道线程池要多大，太大了内存可能不够，也不可行。

第二个办法：NIO（非阻塞式IO）方式
因为read()方法堵塞了，所有要开辟多个线程，如果什么方法能使read()方法不堵塞，这样就不用开辟多个线程了，这就用到了另一个IO模型，NIO（非阻塞式IO）。

NIO

  • 当用户进程发出read操作时，如果kernel中的数据还没有准备好，那么它并不会block用户进程，而是立刻返回一个error。

  • 从用户进程角度讲 ，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。

  • 用户进程判断结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。

  • 一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存，然后返回。

  • 所以，NIO特点是用户进程需要不断的主动询问内核数据准备好了吗？一句话，用轮询替代阻塞！

image.png
在NIO模式中，一切都是非阻塞的：

accept()方法是非阻塞的，如果没有客户端连接，就返回无连接标识
read()方法是非阻塞的，如果read()方法读取不到数据就返回空闲中标识，如果读取到数据时只阻塞read()方法读数据的时间

在NIO模式中，只有一个线程：
当一个客户端与服务端进行连接，这个socket就会加入到一个数组中，隔一段时间遍历一次，
看这个socket的read()方法能否读到数据，这样一个线程就能处理多个客户端的连接和读取了。

案例

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;

public class RedisServerNIO
{
    static ArrayList<SocketChannel> socketList = new ArrayList<>();
    static ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

    public static void main(String[] args) throws IOException
    {
        System.out.println("---------RedisServerNIO 启动等待中......");
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress("127.0.0.1",6379));
        serverSocket.configureBlocking(false);//设置为非阻塞模式

        while (true)
        {
            for (SocketChannel element : socketList)
            {
                int read = element.read(byteBuffer);
                if(read > 0)
                {
                    System.out.println("-----读取数据: "+read);
                    byteBuffer.flip();
                    byte[] bytes = new byte[read];
                    byteBuffer.get(bytes);
                    System.out.println(new String(bytes));
                    byteBuffer.clear();
                }
            }

            SocketChannel socketChannel = serverSocket.accept();
            if(socketChannel != null)
            {
                System.out.println("-----成功连接: ");
                socketChannel.configureBlocking(false);//设置为非阻塞模式
                socketList.add(socketChannel);
                System.out.println("-----socketList size: "+socketList.size());
            }
        }
    }
}

NIO存在的问题

NIO成功的解决了BIO需要开启多线程的问题，NIO中一个线程就能解决多个socket，但是还存在2个问题。

问题一：
这个模型在客户端少的时候十分好用，但是客户端如果很多，
比如有1万个客户端进行连接，那么每次循环就要遍历1万个socket，如果一万个socket中只有10个socket有数据，也会遍历一万个socket，就会做很多无用功，每次遍历遇到 read 返回 -1 时仍然是一次浪费资源的系统调用。

问题二：
而且这个遍历过程是在用户态进行的，用户态判断socket是否有数据还是调用内核的read()方法实现的，这就涉及到用户态和内核态的切换，每遍历一个就要切换一次，开销很大。

优点：不会阻塞在内核的等待数据过程，每次发起的 I/O 请求可以立即返回，不用阻塞等待，实时性较好。
缺点：轮询将会不断地询问内核，这将占用大量的 CPU 时间，系统资源利用率较低，所以一般 Web 服务器不使用这种 I/O 模型。

  • **结论：**让Linux内核搞定上述需求，我们将一批文件描述符通过一次系统调用传给内核由内核层去遍历，才能真正解决这个问题。IO多路复用应运而生，也即将上述工作直接放进Linux内核，不再两态转换而是直接从内核获得结果，因为内核是非阻塞的。

IO multiplexing-IO多路复用

文件描述符(FD，句柄）

文件描述符（File descriptor）是计算机科学中的一个术语，是一个用于表述指向文件的引用的抽象化概念。**文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。**当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。在程序设计中，文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

是什么

一种同步的IO模型，实现一个线程监视多个文件句柄，一旦某个文件句柄就绪就能够通知到对应应用程序进行相应的读写操作，没有文件句柄就绪时就会阻塞应用程序，从而释放CPU资源。

**I/O：**网络IO，尤其在OS层面指数据在内核态和用户态之间的读写操作
**多路：**多个客户端连接
**复用：**复用一个或者几个线程
IO多路复用：也就是说一个或一组线程处理多个TCP连接，使用单进程就能够实现同时处理多个客户端的连接无需创建或者维护过多的进程/线程。
一句话：
就是一个服务端进程可以同时处理多个套接字描述符。

:::warning
将用户socket对应的文件描述符(FileDescriptor)注册进epoll，然后epoll帮你监听哪些socket上有消息到达，这样就避免了大量的无用操作。此时的socket应该采用非阻塞模式。这样，整个过程只在调用**select、poll、epoll**这些调用的时候才会阻塞，收发客户消息是不会阻塞的，整个进程或者线程就被充分利用起来，这就是事件驱动，所谓的**reactor**反应模式。
:::

reactor反应模式

Reactor 模式，是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor 模式也叫 Dispatcher 模式。即 I/O 多路复用统一监听事件，收到事件后分发(Dispatch 给某进程)，是编写高性能网络服务器的必备技术。

Reactor 模式中有 2 个关键组成：
1）Reactor：Reactor 在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对 IO 事件做出反应。 它就像公司的电话接线员，它接听来自客户的电话并将线路转移到适当的联系人；
2）Handlers：处理程序执行 I/O 事件要完成的实际事件，类似于客户想要与之交谈的公司中的实际办理人。Reactor 通过调度适当的处理程序来响应 I/O 事件，处理程序执行非阻塞操作。

大家都用过nginx，nginx使用epoll接收请求，ngnix会有很多链接进来， epoll会把他们都监视起来，然后像拨开关一样，谁有数据就拨向谁，然后调用相应的代码处理。redis类似同理，这就是IO多路复用原理，有请求就响应，没请求不打扰。
:::success
实现IO多路复用的模型有3种：可以分为select->poll->epoll三个阶段来描述
:::

select方法

image.png

  • select 函数监视的文件描述符分3类，分别是readfds、writefds和exceptfds，将用户传入的数组拷贝到内核空间
  • 调用后select函数会阻塞，直到有描述符就绪（有数据 可读、可写、或者有except）或超时（timeout指定等待时间，如果立即返回设为null即可），函数返回。
  • 当select函数返回后，可以通过遍历fdset，来找到就绪的描述符。

image.png
image.png
image.png

优点

select 其实就是把NIO中用户态要遍历的fd数组(我们的每一个socket链接，安装进ArrayList里面的那个)拷贝到了内核态，让内核态来遍历，因为用户态判断socket是否有数据还是要调用内核态的，拷贝到内核态后，这样遍历判断的时候就不用一直用户态和内核态频繁切换了

缺点

1、bitmap最大1024位，一个进程最多只能处理1024个客户端
2、&rset不可重用，每次socket有数据就相应的位会被置位
3、文件描述符数组拷贝到了内核态(只不过无系统调用切换上下文的开销。（内核层可优化为异步事件通知）)，仍然有开销。select 调用需要传入 fd 数组，需要拷贝一份到内核，高并发场景下这样的拷贝消耗的资源是惊人的。（可优化为不复制）
4、select并没有通知用户态哪一个socket有数据，仍然需要O(n)的遍历。select 仅仅返回可读文件描述符的个数，具体哪个可读还是要用户自己遍历。（可优化为只返回给用户就绪的文件描述符，无需用户做无效的遍历）

小总结

select方式，既做到了一个线程处理多个客户端连接（文件描述符），又减少了系统调用的开销（多个文件描述符只有一次 select 的系统调用 + N次就绪状态的文件描述符的 read 系统调用）。

poll方法

image.png
image.png
image.png

优点

1、poll使用pollfd数组来代替select中的bitmap，数组没有1024的限制，可以一次管理更多的client。它和 select 的主要区别就是，去掉了 select 只能监听 1024 个文件描述符的限制。

2、当pollfds数组中有事件发生，相应的revents置位为1，遍历的时候又置位回零，实现了pollfd数组的重用

缺点

1、pollfds数组拷贝到了内核态，仍然有开销
2、poll并没有通知用户态哪一个socket有数据，仍然需要O(n)的遍历

epoll方法

image.png
image.png

int epoll_create(int size)参数size并不是限制了epoll所能监听听述符最大个数，只是对内核初始分配内部数据结构的一个建议
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)见上图
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)等待epfd上的io事件，最多返回maxevents个事件。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大。

image.png
image.png
多路复用快的原因在于，操作系统提供了这样的系统调用，使得原来的 while 循环里多次系统调用变成了一次系统调用 + 内核层遍历这些文件描述符。

epoll是现在最先进的IO多路复用器，Redis、Nginx，linux中的Java NIO都使用的是epoll。
1、一个socket的生命周期中只有一次从用户态拷贝到内核态的过程，开销小。
2、使用event事件通知机制，每次socket中有数据会主动通知内核，并加入到就绪链表中，不需要遍历所有的socket。

Reactor模式

单Reactor单线程

image.png

  • Reactor对象通过select监控客户端请求事件，收到事件后通过Dispatch进行分发。
  • 如果是建立连接的请求，就由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后的业务处理。
  • 如果不是连接，则Reactor会分发调用连接对应的handler来响应。

优点：

  • 简单，没有多线程、进程通信、竞争问题

缺点：

  • 无法发挥多核CPU的性能。Handler在处理某个连接的业务时，整个进程无法处理其他连接时间，导致性能瓶颈。
  • 线程终止或者死循环，会导致整个系统的通信模块不可用，不能接收和处理外部信息，造成节点故障。

Redis采用这个模型

单Reactor多线程

image.png

  • Reactor对象通过select监控客户端请求事件，收到事件后通过Dispatch进行分发。
  • 如果是建立连接的请求，就由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后的响应事件。
  • 如果不是连接，则Reactor会分发调用连接对应的handler来响应。
  • handler通过read读取数据后，不处理，而是分发给后续的worker线程池的某个线程处理业务。
  • worker线程池的某个线程完成业务后，将结果返回给handler。
  • handler收到响应后，通过send将结果返回给client。

优点

  • 充分利用多核CPU能力

缺点

  • 多线程数据共享和访问比较复杂，reactor处理所有事件的监听和响应，在单线程运行，在高并发场景容易出现性能瓶颈。

主从Reactor多线程

image.png

  • 主线程通过select监听连接事件，收到后，通过Acceptor处理连接事件。
  • Acceptor处理连接事件完成后，主线程将连接分配给SubReactor。
  • SubReactor会创建handler处理read请求，，不处理，而是分发给后续的worker线程池的某个线程处理业务。
  • worker线程池的某个线程完成业务后，将结果返回给handler。
  • handler收到响应后，通过send将结果返回给client。
  • 主线程可以对应多个子线程。

Netty模型

image.png

零拷贝

传统 IO 问题

传统的 IO 将一个文件通过 socket 写出
内部工作流程是这样的：

  1. java 本身并不具备 IO 读写能力，因此 read 方法调用后，要从 java 程序的用户态切换至内核态，去调用操作系统（Kernel）的读能力，将数据读入内核缓冲区。这期间用户线程阻塞，操作系统使用 DMA（Direct Memory Access）来实现文件读，其间也不会使用 cpu

DMA 也可以理解为硬件单元，用来解放 cpu 完成文件 IO

  1. 从内核态切换回用户态，将数据从内核缓冲区读入用户缓冲区（即 byte[] buf），这期间 cpu 会参与拷贝，无法利用 DMA
  2. 调用 write 方法，这时将数据从用户缓冲区（byte[] buf）写入 socket 缓冲区，cpu 会参与拷贝
  3. 接下来要向网卡写数据，这项能力 java 又不具备，因此又得从用户态切换至内核态，调用操作系统的写能力，使用 DMA 将 socket 缓冲区的数据写入网卡，不会使用 cpu

可以看到中间环节较多，java 的 IO 实际不是物理设备级别的读写，而是缓存的复制，底层的真正读写是操作系统来完成的

  • 用户态与内核态的切换发生了 3 次，这个操作比较重量级
  • 数据拷贝了共 4 次

NIO 优化

通过 DirectByteBuf

  • ByteBuffer.allocate(10) HeapByteBuffer 使用的还是 java 内存
  • ByteBuffer.allocateDirect(10) DirectByteBuffer 使用的是操作系统内存


大部分步骤与优化前相同，不再赘述。唯有一点：java 可以使用 DirectByteBuf 将堆外内存映射到 jvm 内存中来直接访问使用

  • 这块内存不受 jvm 垃圾回收的影响，因此内存地址固定，有助于 IO 读写
  • java 中的 DirectByteBuf 对象仅维护了此内存的虚引用，内存回收分成两步
    • DirectByteBuf 对象被垃圾回收，将虚引用加入引用队列
    • 通过专门线程访问引用队列，根据虚引用释放堆外内存
  • 减少了一次数据拷贝，用户态与内核态的切换次数没有减少

进一步优化（底层采用了 linux 2.1 后提供的 sendFile 方法），java 中对应着两个 channel 调用 transferTo/transferFrom 方法拷贝数据

  1. java 调用 transferTo 方法后，要从 java 程序的用户态切换至内核态，使用 DMA将数据读入内核缓冲区，不会使用 cpu
  2. 数据从内核缓冲区传输到 socket 缓冲区，cpu 会参与拷贝
  3. 最后使用 DMA 将 socket 缓冲区的数据写入网卡，不会使用 cpu

可以看到

  • 只发生了一次用户态与内核态的切换
  • 数据拷贝了 3 次

进一步优化（linux 2.4）

  1. java 调用 transferTo 方法后，要从 java 程序的用户态切换至内核态，使用 DMA将数据读入内核缓冲区，不会使用 cpu
  2. 只会将一些 offset 和 length 信息拷入 socket 缓冲区，几乎无消耗
  3. 使用 DMA 将 内核缓冲区的数据写入网卡，不会使用 cpu

整个过程仅只发生了一次用户态与内核态的切换，数据拷贝了 2 次。所谓的【零拷贝】，并不是真正无拷贝，而是在不会拷贝重复数据到 jvm 内存中，零拷贝的优点有

  • 更少的用户态与内核态的切换
  • 不利用 cpu 计算，减少 cpu 缓存伪共享
  • 零拷贝适合小文件传输
＆u204
关注
  • 26
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解磁盘IO、网络IO、零拷贝IO、BIO、NIO、AIO、IO多路复用(select、poll、epoll)
雷恩Layne
02-22 5633
文章很长，但是很用心！ 文章目录1. 什么是I/O2. 磁盘IO3. 网络IO4. IO中断与DMA5. 零拷贝IO6. BIO7. NIO8. IO多路复用8.1 select8.2 poll8.3 epoll9. AIO10. 总结 1. 什么是I/O 在计算机操作系统中，所谓的I/O就是输入（Input）和输出（Output），也可以理解为读（Read）和写（Write)，针对不同的对象，I/O模式可以划分为磁盘IO模型和网络IO模型。 IO操作会涉及到用户空间和内核空间的转换，先来理解以下规则：
异步IO、epoll、零拷贝
lonelyVM的博客
07-21 1731
异步 IO 模型（AIO）是真正意义上的无阻塞的IO操作，但是目前只有windows支持AIO，linux内核暂时不支持。 所以，理论上liinux的epoll尽管很猛，但是read的第二阶段：内核空间到用户空间还是阻塞的。 参考：WX收藏夹：你管这叫IO多路复用 ...
IO、零拷贝、多路复用、connection、池化
梭哈是一种智慧
07-05 1875
每日一学： IO、零拷贝、多路复用、connection、池化、线程池
五种网络IO模型
清风
07-05 5740
  本文重点在于介绍五种网络IO模型  网络IO，会涉及到两个系统对象，一个是用户空间调用IO的进程或线程，另一个是内核空间的内核系统，比如发生IO操作read时，它会经历两个阶段。  因为在以上两个阶段上各有不同的情况，所以出现了多种网络 IO 模型。  本专栏知识点是通过零声教育的线上课学习，进行梳理总结写下文章，对c/c++linux课程感兴趣的读者，可以点击链接 C/C++后台高级服务器课程介绍 详细查看课程的服务。  .........
五种IO模型：操作系统五种IO模型大全
热门推荐
緑水長流*z
05-10 10万+
包含操作系统的应用与内核，CPU指令等级，内核空间、用户空间，内核态与用户态；网络IO，磁盘IO，内存IO，异步/同步IO，阻塞/非阻塞IO，以及操作系统的五种IO模型，阻塞IO，非阻塞IO，复用IO（select、poll、epoll）、信号驱动IO模型，异步IO模型等...
一文搞懂网络通信的基石✅IO模型与零拷贝
关注菜菜的后端私房菜，获取更多技术干货~
07-23 891
IO模型的提出是为了解决CPU在内存的速度与外部设备加载到内存速度的差异在操作系统中为了安全使用系统资源，IO时会涉及到用户态、内核态的切换IO阶段通常分为准备数据和拷贝数据，准备数据主要由DMA将外部设备数据拷贝到内核缓冲区，拷贝数据是将内核缓冲区拷贝到用户缓冲区同步阻塞IO模型（BIO）发起系统调用后会阻塞到数据拷贝完成，不适合处理高并发网络通信的场景同步非阻塞IO模型使用轮询的方式判断数据是否就绪，就绪再同步阻塞等待数据拷贝。
【IO】IO模型与零拷贝
Annancqxxx的博客
12-24 1510
正在运行的程序其实就是系统中的一个进程，操作系统会为每一个进程分配内存空间，而内存空间分为两部分，一部分是用户空间，这是用户进程访问的内存区域；另一部分是内核空间，是操作系统内核访问的内存区域。如网络、磁盘IO等操作，出于安全性考虑，用户进程不能直接与外部设备进行数据交互，用户进程只能向操作系统发起IO调用请求，由操作系统内核与外部设备进行数据交互，完成真正的IO操作。
网络IO模型 Linux环境下的network IO 高清 目录 书签
04-04
在Linux环境下，网络I/O（Input/Output）模型是系统进行网络通信的重要组成部分，它涉及到如何高效地处理来自网络的数据传输。本资源主要探讨的是在Linux操作系统中的网络I/O模型，包括其工作原理、常见类型以及优化...
零拷贝和多路复用模型~皎月
weixin_44012853的博客
03-12 678
零拷贝和多路复用模型简记
网络同步IO模型——多路复用（IO Multiplexing）
m0_56709806的博客
07-22 3444
多路复用
​数据链路层——流量控制&可靠传输机制 ​
qq_25467441的博客
09-09 728
例题:一个信道的数据传输率为4kb/s ,单向传播时延为30ms ,如果使停止-等待协议的信道最大利用率达到80%,要求的数据帧长度至少为。设数据帧的长度为L比特，则发送方发送全部的数据需要时间：L/4。“停止-等待”就是每发送完一个分组就停止发送，等待对方确认，在收到确认后再发送下一个分组。因为是在讨论可靠传输的原理,所以并不考虑数据是在哪一个层次上传送的。发送方在一个发送周期内,有效地发送数据所需要的时间占整个发送周期的比率。数据链路层的流量控制是点对点的，而传输层的流量控制是端到端的。
200 Gb/s和400 Gb/s网络
dncsk的专栏
09-07 1423
116.200 Gb/s和400 Gb/s网络简介写在前面 :1.需要英文原文请自行官网下载2.本人无授权故亦不接受相关付费服务 如有商业性需求建议寻找有资质的书籍供应商购买3.翻译纯粹为爱发电,因为机器翻译所以错乱较多 建议参照英文原文对比使用 4.欢迎评论区提出建议或意见 原则上不删除评论 原则上不回复私信 和解呈现200GBASE-RPCSPMDIEEEStd802.3-2022，IEEE以太网标准第八节116.200Gb/s和400Gb/s网络116.1概述116.1范围本条款描述了200千兆位和4
[网络]HTTP协议 Cookie与Session
m0_74910646的博客
09-07 778
HTTP Cookie（也称为 Web Cookie、浏览器 Cookie 或简称 Cookie）是服务器发送到 用户浏览器并保存在浏览器上的一小块数据，它会在浏览器之后向同一服务器再次发 起请求时被携带并发送到服务器上。通常，它用于告知服务端两个请求是否来自同一浏览器，如保持用户的登录状态、记录用户偏好等。HTTP Session 是服务器用来跟踪用户与服务器交互期间用户状态的机制。由于 HTTP 协议是无状态的（每个请求都是独立的），因此服务器需要通过 Session 来记住用户的信息。
145-Linux权限维持&Rootkit后门&Strace监控&Alias别名&Cron定时任务
DamnVanish的博客
09-07 847
Linux中最强权限维持rootkit
网络安全宣传周 | DNS安全威胁与应对措施分享
最新发布
weixin_53018687的博客
09-12 678
然而，DNS协议在设计初期只注重功能的实现，未充分考虑安全验证机制，缺乏有效的安全防御手段，DNS协议数据包往往能够在网络中畅通无阻，为攻击者提供了可乘之机，这一天生的设计缺陷使得DNS系统天然地成为了安全领域的薄弱环节。DNS劫持：DNS劫持是指攻击者通过篡改DNS解析结果，将用户的流量重定向到不同的IP地址，通常是恶意网站。DNS泛洪攻击：DNS洪泛攻击是一种拒绝服务攻击，攻击者通过发送大量的DNS请求，通常是伪造的或毫无意义的查询，消耗DNS服务器的资源，使其无法响应合法的查询请求。
亚信安全出席第五届国际反病毒大会 探究AI现代网络勒索治理
亚信安全官方账号的博客
09-09 424
亚信安全出席活动并发表题为《AI时代下现代网络勒索治理》的演讲
网络分析仪仪器校准要怎么进行检测？容易出现哪些误差？
2401_83476848的博客
09-12 254
误差修正是对已知校准标准的测量，这些测量值存储在分析仪的存储器之中，数据用于计算误差模型。系统误差是由矢量网络分析仪和测试设置之中的缺陷引起的，是重复性误差，并假设它不随时间变化。校准件的使用可以达到减少误差的目的。2.开关重复性误差：分析仪中用于切换源衰减器设置的机械式RF开关，有时当机械式RF开关被启动时，触点的闭合方式与上次启动时不同。通过仪器校准措施增强，消除反射测量之中的三个系统误差:指向性、源匹配、频率响应。:是由于仪器或测试系统仪器校准之后性能发生变化引起的，主要是温度变化引起的。
综合DHCP、ACL、NAT、Telnet和PPPoE进行网络设计练习
m0_62909438的博客
09-07 1144
通过学习到的DHCP、NAT、ACL、Telnet和PPPoE技术，进行综合实验配置，掌握这些技术的配置，了解其用法，加深命令印象。
WireShark抓包软件介绍和安装
m0_49476241的博客
09-08 942
Wireshark 是一个广泛使用的网络协议分析工具，它提供了强大的功能用于捕获、分析和调试网络流量。
异步零拷贝网络IO的必要性 - Ulrich Drepper
目前，POSIX异步I/O接口被广泛使用，但它们并不完全适合网络I/O，且存在诸如非零拷贝、通知机制复杂或速度慢等问题。 这篇讨论强调了网络I/O性能优化的重要性，提出了异步接口和零拷贝技术作为解决方案，并指出了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值