NIO原理及实战

已于 2022-04-16 10:54:33 修改
阅读量1.4k 收藏 7
点赞数 2
分类专栏： netty 文章标签： Netty
于 2022-04-14 22:42:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42511550/article/details/124180814
版权

Netty

基本介绍

在这里插入图片描述

细节描述

1）Java NIO全称java non-blocking IO ,是指JDK提供的新的API，从JDK1.4开始，Java提供了一系列改进输入/输出的新特性，被统称为NIO，同步非阻塞
2）NIO相关的类都放在java.nio包及子包下，并且对原java.io包中很多类进行改写

在这里插入图片描述
3）NIO有三大核心部分： Channel（通道），Buffer（缓冲区），Selector（选择器）
4）NIO是面向缓冲区，或者面向块编程。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程的灵活性。
5）Java NIO的非阻塞模式，使一个线程从某通道中发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有可用数据，就什么也不会获取，而不是保持线程阻塞在那里，所以直至数据变得可以读取之前，该线程可以继续做其他得事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但是不需要等待它完全写入，这个线程同时可以做别的事情。
6）NIO可以做到一个线程来处理多个操作，假设有100个请求过来，根据实际情况，可以分配5或者10个线程来处理。如果是BIO的话，那么就需要对每个请求建立一个线程。
7）HTTP2.0使用lO多路复用技术，做到同一个连接并发处理多个请求，并且并发请求的数量比HTTP1.1大了好几个数量级。

BIO和NIO比较

1）BIO以流的方式处理数据，而NIO以块的方式处理数据，块I/O效率比流IO高很多
2）BIO是阻塞的，NIO是非阻塞的
3）BIO是基于字节流和字符流进行操作，而NIO基于Channel和Buffer进行操作，数据总是从通道读取到缓冲区，或者从缓冲区读取到通道。Selector用于监听多个通道的事件（比如连接请求，数据到达等），因此可以用单个线程就能监听多个客户端通道。

NIO核心原理

在这里插入图片描述

Selector ，Channel和Buffer的关系图
1）每个Channel都会对应一个Buffer
2）Selector对应一个线程，一个线程对应多个Channel（连接）
3）该图反应you三个Channel注册到Selector
4）程序切换到那个Channel是由事件决定的
5）Selector会根据不同的事件在各个通道进行切换
6）Buffer就是一个内存块，底层是一个数组
7）数据的读取和写入都是通过Buffer，可以读也可以写，需要flip方法切换，BIO要么是输入流要么是输出流
8）Channel是双向的，可以返回底层操作系统的情况，比如linux

缓冲区

基本介绍
缓冲区（Buffer）: 缓冲区本质就是一个可以读写数据的内存块，可以简单的理解为一个容器对象，该对象提供了一组方法，可以更轻松的使用内存块，缓冲区对象内置一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供了从文件，网络读取数据通道，但是读取和写入数据必须经过Buffer

在这里插入图片描述
在这里插入图片描述

常用的buffer子类
1）ByteBuffer 存储字节数据到缓冲区
2）ShortBuffer 存储短整型数据数据到缓冲区
3）CharBuffer 存储字符数据到缓冲区
4）IntBuffer 存储整数数据到缓冲区
5）LongBuffer 存储长整型数据到缓冲区
6）DoubleBuffer 存储小数数据到缓冲区
7）FloatBuffer 存储小数数据到缓冲区
在这里插入图片描述

通道

基本介绍
1）NIO通道类似流，但是区别如下

  • 通道可以同时进行读写，而流只能读或者写
  • 通道可以实现异步读写数据
  • 通道可以从缓冲区读数据，也可以写数据到缓冲区

2）Channel在NIO是一个接口

public interface Channel extends Closeable {
3）常见的channel ： FileChannel(用于文件读写),DatagramChannel（用于UDP数据读写）,SeverSocketChannel和SocketChannel（用于TCP的数据读写）

在这里插入图片描述
关于buffer和channel注意细节
1）ByteBuffer支持类型化的put和get,put放入什么类型，get就获取什么类型，否则就可能有BufferUnderflowException
2）可以将普通的Buffer转换为只读Buffer
3）NIO还支持通过多个Buffer（Buffer数组来完成）即Scattering和Gathering
4）NIO提供了MappedByteBuffer可以让文件直接在内存中进行修改

Selector

基本介绍
1）java的NIO,用非阻塞IO的方式 .可以用一个线程，处理多个客户端连接，就会使用到Selector（选择器）
2）Selector能够检测多个注册通道是否有事件发送，如果有事件发生，便获取事件，然后对每个事件进行相应的处理，这样一个线程就可以去管理多个通道，也就是管理多个连接和请求
3）避免了多线程的上下问切换导致的开销

在这里插入图片描述
特点说明
1）Netty的IO线程NioEventLoop聚合了Selector(选择器也叫多路复用器)，可以同时并发处理成百上千个客户端连接。
2）当线程从客户端Socket通道进行读写数据的时，若没有数据可以用，该线程可以进行其他的任务。
3）线程通常以非阻塞IO的空闲时间用于在其他通道的IO操作，所以单独线程可以管理多个输入和输出通道
4）由于读写操作是非阻塞的，充分提高了IO线程的运行效率，避免由于IO阻塞导致线程挂起

在这里插入图片描述
注意事项
1）NIO中的ServerSocketChannel功能类似ServerSocket,SocketChannel类似Socket
在这里插入图片描述
说明：
1，当客户端进行连接的时候，会通过ServerSocketChannel得到SocketChannel
2，Selector进行监听selector方法，返回有事件发生的通道个数
3，将socketChannel注册到Selector上，register(Selector sel,int ops),一个selector上可以注册多个SocketChannel.
4，注册返回一个SelectionKey,会和该Selector关联
5，进一步得到各个SelectionKey(有事件发生)
6，通过SelectionKey反向获取SocketChannel,方法Channel
7，可以通过得到的channel进行业务处理
8，业务处理

SelectionKey 在这里插入图片描述

SeverSockerChannel
在这里插入图片描述 SocketChannel
在这里插入图片描述

应用实例

应用实例1-本地文件写数据

实例要求:
1）使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)， 将 “hello，world!” 写入到file.txt 中
2）文件不存在就创建

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileOper01 {

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

        String str = "hello,world!";
        //创建输出流
        FileOutputStream outputStream = new FileOutputStream("file.text");
        //获取通道
        FileChannel channel = outputStream.getChannel();

        //获取缓冲区对象
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        //加载数据到缓冲区内存中
        byteBuffer.put(str.getBytes("UTF-8"));

        //缓冲区翻转
        byteBuffer.flip();
        //把缓冲区的数据加载到通道中
        channel.write(byteBuffer);

        //关闭通道和流
        channel.close();
        outputStream.close();
    }
}
应用实例2-本地文件读数据

实例要求:

  1. 使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)， 将 file.txt 中的数据读入到程序，并显示在控制台屏幕
  2. 假定文件已经存在
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileOper02 {

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

        //创建输出流
        FileInputStream fileInputStream = new FileInputStream("file.text");
        //获取通道
        FileChannel channel = fileInputStream.getChannel();

        //获取缓冲区对象
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        int read = channel.read(byteBuffer);
        System.out.println("读取的字节数" + read);
        System.out.println(new String(byteBuffer.array()));

        //关闭通道和流
        channel.close();
        fileInputStream.close();
    }
}
应用实例3-使用一个Buffer完成文件读取

实例要求:

  1. 使用 FileChannel(通道) 和 方法 read , write，完成文件的拷贝
  2. 拷贝一个文本文件 1.txt , 放在项目下即可
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 实例要求:
 * 使用 FileChannel(通道) 和 方法  read , write，完成文件的拷贝
 *
 * 拷贝一个文本文件 1.txt  , 放在项目下即可
 * 代码演示
 */
public class NIOFileOper03 {

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

        //创建输出流
        FileInputStream fileInputStream = new FileInputStream("file.text");
        //获取通道
        FileChannel channel = fileInputStream.getChannel();

        //获取缓冲区对象
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        channel.read(byteBuffer);
        System.out.println(new String(byteBuffer.array()));
        //缓冲区翻转
        byteBuffer.flip();


        FileOutputStream fileOutputStream = new FileOutputStream("fileCopy.text");
        FileChannel outputChanel = fileOutputStream.getChannel();
        outputChanel.write(byteBuffer);

        //关闭通道和流
        channel.close();
        outputChanel.close();
        fileInputStream.close();
        fileOutputStream.close();
    }
}
应用实例4-拷贝文件transferFrom 方法

实例要求:
1）使用 FileChannel(通道) 和 方法 transferFrom ，完成文件的拷贝
2）拷贝一张图片

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;


public class NIOFileOper04 {

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

        FileInputStream fis = new FileInputStream("01.jpg");
        FileOutputStream fos = new FileOutputStream("01cp.jpg");

        FileChannel fosChannel = fos.getChannel();
        FileChannel fisChannel = fis.getChannel();

        System.out.println("此通道文件的大小"+fisChannel.size());
        //从目标通道拷贝数据到当前通道
        fosChannel.transferFrom(fisChannel, 0, fisChannel.size());
        fos.close();
        fis.close();
        fisChannel.close();
        fosChannel.close();
        System.out.println("图片拷贝完成。。。");
    }
}
应用实例5-NIO 非阻塞 网络编程快速入门

案例要求:
编写一个 NIO 入门案例，实现服务器端和客户端之间的数据简单通讯（非阻塞）
目的：理解NIO非阻塞网络编程机制
在这里插入图片描述
服务端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer1 {

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

        //1 得到一个serverSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2 绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(8888));
        //3 配置非阻塞
        serverSocketChannel.configureBlocking(false);
        //4 得到一个Selector对象
        Selector selector = Selector.open();

        //5 向Selector注册ServerSocketChannel
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //6 开始工作
        while (true) {
            //6.1 监听客户端
            if (selector.select(1000) == 0) {
                System.out.println("等待1s,无客户端连接");
                continue;
            }

            //6.2 判断通道事件
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
            //遍历通道
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                if (key.isAcceptable()) {
                    //客户端连接请求事件
                    //接受通道
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    //配置非阻塞
                    socketChannel.configureBlocking(false);
                    //注册到selector
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                    System.out.println("有client连接请求过来");

                }
                if (key.isReadable()) {
                    //读取客户端事件
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    socketChannel.read(buffer);
                    System.out.println("接受客户端数据" + new String(buffer.array()));
                }
                // 6.3 手动从集合中移除当前key,防止重复处理
                keyIterator.remove();
            }

        }
    }
}

客户端

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

public class NIOClient1 {

    public static void main(String[] args) throws IOException {
        //1 得到一个Socker连接
        SocketChannel socketChannel = SocketChannel.open();
        //2 配置非阻塞
        socketChannel.configureBlocking(false);
        //3 绑定端口ip
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8888);
        //4连接
        if (!socketChannel.connect(socketAddress)) {
            while (!socketChannel.finishConnect()) {
                //nio非阻塞式
                System.out.println("客户端: 因为连接需要时间，客户端不会阻塞，可以做个计算工作...");
            }
        }
        //写入数据

        ByteBuffer byteBuffer = ByteBuffer.wrap("Hello Netty!!!".getBytes());
        socketChannel.write(byteBuffer);

        System.in.read();
        System.out.println("客户端完成工作");
    }
}
应用实例6 NIO 网络编程应用实例-群聊系统

实例要求:
1）编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）
2）实现多人群聊
3）服务器端：可以监测用户上线，离线，并实现消息转发功能
4）客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发得到)

import com.atguigu.netty.qq.ChatClient;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class GroupChatClient {
    private final String HOST = "127.0.0.1"; //服务器地址
    private int PORT = 6667; //服务器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String userName;

    public GroupChatClient() throws IOException {
        //得到选择器
        selector = Selector.open();
        //连接远程服务器
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //注册选择器并设置为 read
        socketChannel.register(selector, SelectionKey.OP_READ);
        //得到客户端 IP 地址和端口信息，作为聊天用户名使用
        userName = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(userName + " is ok ~");
    }

    //向服务器端发送数据
    public void sendInfo(String info) throws Exception {
        //如果控制台输入 exit 就关闭通道，结束聊天
        if (info.equalsIgnoreCase("exit")) {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
            socketChannel.close();
            socketChannel = null;
            return;
        }
        info = userName + " 说: " + info;
        try {
            //往通道中写数据
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //从服务器端接收数据
    public void readInfo() {
        try {
            int readyChannels = selector.select();
            if (readyChannels > 0) { //有可用通道
                Set selectedKeys = selector.selectedKeys();
                Iterator keyIterator = selectedKeys.iterator();
                while (keyIterator.hasNext()) {
                    SelectionKey sk = (SelectionKey) keyIterator.next();
                    if (sk.isReadable()) {
                        //得到关联的通道
                        SocketChannel sc = (SocketChannel) sk.channel();
                        //得到一个缓冲区
                        ByteBuffer buff = ByteBuffer.allocate(1024);
                        //读取数据并存储到缓冲区
                        sc.read(buff);
                        //把缓冲区数据转换成字符串
                        String msg = new String(buff.array());
                        System.out.println(msg.trim());
                    }
                    keyIterator.remove(); //删除当前 SelectionKey，防止重复处理
                }
            } else {
                //会检测到没有可用的channel ，可以退出
                System.out.println("没有可用channel ...");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception  {
        //创建一个聊天客户端对象
        GroupChatClient chatClient = new GroupChatClient();
        new Thread() { //单独开一个线程不断的接收服务器端广播的数据
            public void run() {
                while (true) {
                    chatClient.readInfo();
                    try { //间隔 3 秒
                        Thread.currentThread().sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        Scanner scanner = new Scanner(System.in);
        //在控制台输入数据并发送到服务器端
        while (scanner.hasNextLine()) {
            String msg = scanner.nextLine();
            chatClient.sendInfo(msg.trim());
        }
    }
}



import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.text.SimpleDateFormat;
import java.util.Iterator;


public class GroupChatServer {
    private Selector selector;
    private ServerSocketChannel listenerChannel;
    private static final int PORT = 6667; //服务器端口

    public GroupChatServer() {
        try {
            // 得到选择器
            selector = Selector.open();
            // 打开监听通道
            listenerChannel = ServerSocketChannel.open();
            // 绑定端口
            listenerChannel.socket().bind(new InetSocketAddress(PORT));
            // 设置为非阻塞模式
            listenerChannel.configureBlocking(false);
            // 将选择器绑定到监听通道并监听 accept 事件
            listenerChannel.register(selector, SelectionKey.OP_ACCEPT);
            printInfo("服务器 ok.......");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void listen() {
        try {
            while (true) { //不停轮询
                int count = selector.select();//获取就绪 channel
                if (count > 0) {
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        SelectionKey key = iterator.next();
                        // 监听到 accept
                        if (key.isAcceptable()) {
                            SocketChannel sc = listenerChannel.accept();
                        //非阻塞模式
                            sc.configureBlocking(false);
                        //注册到选择器上并监听 read
                            sc.register(selector, SelectionKey.OP_READ);

                            //System.out.println(sc.getRemoteAddress().toString().substring(1) + "online ...");
                            System.out.println(sc.socket().getRemoteSocketAddress().toString().substring(1) + " 上线 ...");
                        //将此对应的 channel 设置为 accept,接着准备接受其他客户端请求
                            key.interestOps(SelectionKey.OP_ACCEPT);
                        }
                        //监听到 read
                        if (key.isReadable()) {
                            readData(key); //读取客户端发来的数据
                        }
                        //一定要把当前 key 删掉，防止重复处理
                        iterator.remove();
                    }
                } else {
                    System.out.println("waitting ...");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void readData(SelectionKey key) {
        SocketChannel channel = null;
        try {
            // 得到关联的通道
            channel = (SocketChannel) key.channel();
            //设置 buffer 缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            //从通道中读取数据并存储到缓冲区中
            int count = channel.read(buffer);
            //如果读取到了数据
            if (count > 0) {
                //把缓冲区数据转换为字符串
                String msg = new String(buffer.array());

                printInfo(msg);
                //将关联的 channel 设置为 read，继续准备接受数据
                key.interestOps(SelectionKey.OP_READ);
                sendInfoToOtherClients(channel, msg); //向所有客户端广播数据
            }
            buffer.clear();
        } catch (IOException e) {
            try {
            //当客户端关闭 channel 时，进行异常如理
                //printInfo(channel.getRemoteAddress().toString().substring(1) + "offline...");
                printInfo(channel.socket().getRemoteSocketAddress().toString().substring(1) + " 离线了 ...");
                key.cancel(); //取消注册
                channel.close(); //关闭通道
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }

    public void sendInfoToOtherClients(SocketChannel except, String msg) throws IOException {
        System.out.println("服务器进行消息转发 ...");
        //转发数据到所有的 SocketChannel 中
        for (SelectionKey key : selector.keys()) {
            Channel targetchannel = key.channel();
            //排除自身
            if (targetchannel instanceof SocketChannel && targetchannel != except) {
                SocketChannel dest = (SocketChannel) targetchannel;
            //把数据存储到缓冲区中
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
            //往通道中写数据
                dest.write(buffer);
            }
        }
    }

    private void printInfo(String str) { //显示消息

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("服务器接收到消息 时间: [" + sdf.format(new java.util.Date()) + "] -> " + str);
    }

    public static void main(String[] args) {
        GroupChatServer server = new GroupChatServer();
        server.listen();
    }
}
大道至简@EveryDay
关注
专栏目录
NIO模式例子
seaboat——a free boat on the sea.（公众号：远洋号）
12-07 2836
NIO模式主要优势是体现在对多连接的管理，对众多连接各种事件的转发让处理变得更加高效，所以一般是服务器端才会使用NIO模式，而对于客户端为了方便及习惯使用阻塞模式的Socket进行通信。所以NIO模式的例子也仅仅看下服务端的实现即可。public class NioServer { private ByteBuffer readBuffer; private Selector selector;
Netty原理及实战应用（中篇）
最新发布
program哲学
08-08 64
详细介绍netty各组件底层原理及应用实战
NIO原理详解
热门推荐
左耳听风的博客
08-18 7万+
1.阻塞与同步 2.BIO与NIO对比 3.NIO简介 4.缓冲区Buffer 5.通道Channel 6.反应堆 7.选择器 8.NIO源码分析 9.AIO 1.阻塞与同步 1）阻塞(Block)和非租塞(NonBlock): 阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候阻塞：往往需要等待缞冲区...
什么是NIO
yuiezt的专栏
07-25 1647
NIO支持面向缓冲区的、基于通道的IO操作，其核心组件包括缓冲区（Buffer）、通道（Channel）和选择器（Selector）。NIO（New Input/Output）作为Java中一种新的IO处理方式，相较于传统的BIO（Blocking Input/Output）具有一系列的优点，但同时也存在一些潜在的缺点。
Java技术分享：NIO实战教程！
xiaoxijinger的博客
06-07 456
Java NIO(New IO)是一个可以替代标准Java IO API的IO API(从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行，线程在读写IO期间不能干其他事情，比如调用socket.read()时，如果服务器一直没有数据传输过来，线程就一直阻塞，而NIO中可以配置socket为非阻塞模式。 Java NIO是在jdk1.4开始使用的，它既可以说成“新I/O”，也可以说成非阻塞式I/O。 下面是j
IO通信之NIO实战
m0_37148920的博客
05-22 179
NIO实战
JAVA-NIO实战
coderyqwh的博客
05-13 319
一、NIO在文件读写方面相对于传统IO来说，性能高很多 /** * 文件读写的NIO * @param args * @throws IOException */ public static void main(String[] args) throws IOException { //1.NIO采用通道+缓存区使得新式的IO操作直接面向缓存区，并且是非阻塞的 //2.Channel是支持读写双向操作，基于RandomAccessFile实现的 RandomAccessFile fi...
NIO网络编程原理与实战.xmind
05-26
https://blog.csdn.net/ykmeory/article/details/115603895
Tomcat原理与实战
08-27
【Tomcat原理与实战】 Tomcat是一个开源的Java Servlet容器，由Apache软件基金会的Jakarta项目维护。它实现了Java EE的Web应用服务器规范，特别是Servlet和JSP规范，是开发和部署Java Web应用程序的常用工具。...
阿里巴巴Java性能调优实战：深入了解NIO的优化实现原理
m0_58336848的博客
06-04 228
答疑课堂：深入了解NIO的优化实现原理 综合查看完近期的留言以后，我的第一篇答疑课堂就顺势诞生了。我将继续讲解 I/O 优化，对大家在 08 讲中提到的内容做重点补充，并延伸一些有关 I/O 的知识点，更多结合实 际场景进行分享。话不多说，我们马上切入正题。 Tomcat 中经常被提到的一个调优就是修改线程的 I/O 模型。Tomcat 8.5 版本之前，默认 情况下使用的是 BIO 线程模型，如果在高负载、高并发的场景下，可以通过设置 NIO 线程 模型，来提高系统的网络通信性能 ...
基于NIO的Netty框架实战-Netty.zip
01-31
这个“基于NIO的Netty框架实战-Netty.zip”压缩包很可能是为学习和实践Netty提供的资源，包含了一个名为"Netty-master"的项目源代码。 Netty 的核心是基于Java NIO（非阻塞I/O）构建的，这使得Netty能够高效处理...
java NIO实战
LIXG425的专栏
01-13 219
 一、NIO应用场景 1、写爬虫 2、做通讯服务器就经常有用，还有些自定义的socket接口什么的。不过现在其实框架很多了。 3、比如游戏服务端 4、与传统IO的优势    在老的IO包中，serverSocket和socket都是阻塞式的，因此一旦有大规模的并发行为，而每一个访问都会开启一个新线程。这时会有大规模的线程上下文切换操作（因为都在等待，所以资源全都被已有的线程吃掉了），这...
NIO原理及案例使用
weixin_30822451的博客
04-18 90
什么是NIO Java提供了一个叫作NIO(New I/O)的第二个I/O系统，NIO提供了与标准I/O API不同的I/O处理方式。它是Java用来替代传统I/O API(自Java 1.4以来)。 它支持面向缓冲的，基于通道的I/O操作方法。 随着JDK 7的推出，NIO系统得到了扩展，统功能和文件处理提供了增强的支持。由于NIO文件类支持的这些新的功能，NIO被广泛应用于文件处理。 N...
NIO的实战教程（简单且高效）
m0_46638350的博客
12-20 534
我们将模拟一个简单的HTTP服务器，它将响应客户端请求并返回一个固定的响应（”Hello, World!我们将使用IO和NIO两种不同的方式实现此服务器。多路复用才是NIO不阻塞的原因。
NIO与BIO的区别、NIO的运行原理和并发使用场景
weixin_34185364的博客
09-21 160
2019独角兽企业重金招聘Python工程师标准>>> ...
Java NIO实战
richard1986317的博客
12-24 141
[size=small] 最近参与实现底层高并发处理的项目，接收socket客户端的连接请求，然后调用主机服务进行通讯。系统需要满足100TPS（吞吐量（tps)＝活动的用户数/响应时间）的性能要求。 通过查阅相关的文献及网上的资料，最终采用java NIO技术方案来实现。系统上线后各方面性能表现不错，也给我们技术团队更多的信心。以下分享一下Java NIO这块的程序，希望对各...
java基础知识--NIO详解及实战
JordanInShenzhen的博客
05-10 322
前面已经介绍了java常见的几种IO操作，包括文件读写、缓冲区的操作等等。这些操作虽然都是我们日常在写业务代码的时候常用的操作，但是还有一种在互联网中也是极其重要的IO，那就是NIO。NIO是jdk1.4版本推出来的新功能，主要是为了解决在网络IO的过程中，同步IO阻塞导致系统资源浪费的场景。所以很多人说NIO，其实都是特指AIO，即异步IO 在介绍NIO（AIO）之前，我们先来看看原来的BIO有什么问题。假如有这么一个场景， ...
NIO原理
雪人奥特曼的博客
12-09 100
阻塞和非阻塞： 阻塞：访问数据时候，数据未准备好，就需要等待，直至数据准备好过后，才去处理其他事情，否则一直等待下去。 非阻塞：访问数据时候，数据未准备好，就直接返回不进行等待。 同步和异步方式： 同步：在获取到返回结果之前不可以进行其他操作。 异步：不用等待返回结果直接进行下一步操作。 IO和NIO的区别 IO ： 从硬盘到内存的读取，面向流的阻塞IO NIO：从内存到硬盘的读取，面向...
Netty自定义文档：NIO原理与实战
这篇文档概述了Netty的基本原理，从NIO底层机制到上层的Channel和Handler机制，以及如何利用Bootstrap和ServerBootstrap构建服务器。理解这些内容有助于开发者高效地使用Netty来构建高性能的网络应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大道至简@EveryDay

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值