03-Java NIO 编程 入门

最新推荐文章于 2023-01-16 15:59:18 发布
最新推荐文章于 2023-01-16 15:59:18 发布
阅读量267 收藏 1
点赞数
文章标签： 网络 python java 多线程 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flowerStream/article/details/122632642
版权

NIO 基本介绍

  1. Java NIO 全称 java non-blocking IO,是指JDK提供的新API,从JDK1.4提供了一系列改进的输入/输出的新特性,被统称为NIO(即New IO),是同步非阻塞的
  2. NIO 相关类都被放在java.nio包及子包下,并对原Java.io包中的很多类进行改写.[基本案例]
  1. NIO 有三大核心部分: Channel(通道),Buffer(缓冲区),Selector(选择器)
  2. NIO是面向缓冲区, 或者面向 块 编程的,数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动,这就增加了处理过程中的灵活性,使用它可以提供非阻塞式的高伸缩性网格
  1. Java NIO 的非阻塞,模式, 使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变得可以读取之前,该线程可以继续做其他的事情,非阻塞写也是如此,一个线程请求写入一些数据到某通道,单不需要等待它完全写入,这个线程同事可以去做其他事情[后面有案例说明]
  2. 通俗理解: NIO是可以做到用一个线程来处理多个操作,假设有10000个请求过来,根据实际情况,可以分配50或者100个线程来处理,不会像之前的阻塞IO那样,非得分配10000个线程
  1. HTTP2.0使用了多路复用技术,做到同一个连接并发处理多个请求,并且并发请求的数量必HTTP1.1大了好几个数量级

案例说明NIO的Buffer

编写代码

package com.dance.netty.nio;

import java.nio.IntBuffer;

public class BasicBuffer {

    public static void main(String[] args) {

        // 新建Buffer
        // 5 容量
        IntBuffer intBuffer = IntBuffer.allocate(5);

        // 向Buffer中存放数据
        for (int i = 0; i < intBuffer.capacity(); i++) {
            IntBuffer put = intBuffer.put(i * 2);
        }

        // 从Buffer中获取数据
        // flip() : 将Buffer转换, 读写切换
        intBuffer.flip();

        // 获取数据
        while (intBuffer.hasRemaining()) {
            System.out.println(intBuffer.get());
        }
    }

}

执行结果

0
2
4
6
8

NIO 和 BIO 的 比较

  1. BIO以流的方式处理数据,而NIO以块的方式处理数据,块 I/O的效率比流 I/O高很多
  2. BIO 是阻塞的, NIO则是非阻塞的
  1. BIO基于字节流和字符流进行操作,而NIO基于Channel(通道)和Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入通道,Selector(选择器)用于监听多个通道的事件(比如L连接请求,数据到达等), 因此使用单个线程就可以监听多个客户端通道

NIO 三大核心原理示意图

一张图描述NIO的 Selector Channel Buffer 的关系

Selector Channel Buffer的关系图(简单版)

关系图说明

  1. 每个channel都会对应一个Buffer
  2. Selector对应一个线程, 一个线程对应多个channel(连接)
  1. 该图反应了有三个Channel注册到 该Selector //程序
  2. 程序切换到那个Channel是由事件决定的, Event是一个重要的概念
  1. Selector 会根据不同的事件,在各个通道上切换
  2. BUffer就是一个内存块, 底层就是一个数组
  1. 数据的读取写入是通过BUffer, 这个和BIO不同, BIO中要么是输入流,或者是输出流, 不能双向,但是NIO的Buffer是可以读也可以写的,,需要调用flip方法切换, channel也是双向的,可以返回底层操作系统的情况,比如Linux,底层操作系统通道就是双向的

重点

Buffer可以通过调用flip方法切换读写

缓冲区(Buffer)

基本介绍

缓冲区(Buffer) : 缓冲区本质上是一个可以读写数据的内存块, 可以理解成是一个容器对象(含数组), 该对象提供了一组方法,可以更轻松的使用内存块,缓冲区内置了一些机制,能够跟踪和记录缓冲区的状态变化情况,Channel提供了从文件,网络读取数据的渠道,但是读取或写入的数据必须经由Buffer, 如图: [后面举例说明]

Buffer类及其子类

  1. 在NIO中, Buffer是一个顶层父类, 它是一个抽象类, 类的层级关系图

  1. Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:

buffer通过控制position游标位置来读取和写入数据

  1. Buffer类相关方法一览

ByteBuffer

从前面可以看出对于Java中的基本数据类型(boolean除外),都有一个Buffer类型与之相对应,最常用的自然是ByteBuffer类(二进制数据), 该类的主要方法如下:

通道(Channel)

基本介绍

  1. NIO的通道类似于流, 但有些区别如下:
    1. 通道可以同时进行读写, 而流只能读或者只能写
    2. 通道可以实现异步读写数据
    1. 通道可以从缓冲读数据,也可以写数据到缓冲
  1. BIO中的Stream是单向的, 例如FileInputStream对象只能进行读取数据的操作, 而NIO中的通道(Channel)是双向的, 可以读操作, 也可以写操作
  2. Channel在NIO中是一个接口
public interface Channel extends Closeable{}
  1. 常用的Channel类有 : FileChannel, DatagramChannel, ServerSocketChannel, 和 SocketChannel

[ServerSocketChannel类似 ServerSocket, SocketChannel 类似 Socket]

  1. FileChannel用于文件的数据读写, DatagramChannel用于UDP数据的读写, ServerSocketChannel和SocketChannel用于TCP的数据读写
  2. 图示

FileChannel 类

FileChannel主要用于对本地文件进行IO操作, 常见的方法有

  • public int read(ByteBuffer dst), 从通道读取数据并放到缓冲区中
  • public int write(ByteBuffer src), 把缓冲区的数据写入通道
  • public Long transferFrom(ReadableByteChannel src, long position, long count), 从目标通道中复制数据到当前通道
  • public long transferTo(long position, long count, WriteableByteChannel target), 把数据从当前通道复制给目标通道

从图中可以看出,相对于Channel来说,往Buffer中read相当于写数据,从Buffer中write相当于读数据

案例1-本地文件写数据

需求

  1. 使用前面学习的ByteBuffer(缓冲), 和FileChannel(通道), 将 "Hello, Flower" 写入到 01.txt 中
  2. 文件不存在就创建

编码

package com.dance.netty.nio.demo;

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

/**
 * 通过Channel写数据到文件
 */
public class FileChannel01 {

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

        // 创建字符串
        String msg = "hello,Flower";

        // 创建输出流
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\zhangyugen@JD.com\\coding\\netty\\src\\main\\resources\\01.txt");

        // 获取FileChannel
        FileChannel channel = fileOutputStream.getChannel();

        // 创建字节缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 将字符串写入缓冲区
        byteBuffer.put(msg.getBytes(StandardCharsets.UTF_8));

        // 重置游标, 读写切换
        byteBuffer.flip();

        // 从缓冲区写入通道
        channel.write(byteBuffer);

        // 关闭文件流
        fileOutputStream.close();

    }

}

执行结果

ok

案例2-本地文件读数据

需求

  1. 使用前面学习后的ByteBuffer(缓冲)和Channel(通道), 将01.txt 中的数据读入到程序,并显示在控制台屏幕
  2. 文件已存在

编码

package com.dance.netty.nio.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 通过Channel从文件读取数据
 */
public class FileChannel02 {

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

        File file = new File("D:\\zhangyugen@JD.com\\coding\\netty\\src\\main\\resources\\01.txt");

        // 创建输入流
        FileInputStream fileInputStream = new FileInputStream(file);

        // 获取FileChannel
        FileChannel channel = fileInputStream.getChannel();

        // 创建字节缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());

        // 将通道中的数据读入到Buffer
        channel.read(byteBuffer);

        // 因为没有使用Buffer 所以不需要flip
        
        // 通过构造String 传入buffer的 底层数组 转成字符串打印
        System.out.println(new String(byteBuffer.array()));

        // 关闭文件流
        fileInputStream.close();

    }

}

执行结果

hello,Flower

案例3-使用一个Buffer完成文件的读取和写入

需求

  1. 使用FileChannel(通道)和 read, write ,完成文件的拷贝
  2. 拷贝 文件 1.txt 到 2.txt

文件准备 01.txt

hello,Flower
    my name is dance, nice to mite you, thanks!

图解

编码

package com.dance.netty.nio.demo;

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

/**
 * 使用通道实现文件拷贝
 */
public class FileChannel03 {

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

        FileInputStream fileInputStream = new FileInputStream("src/main/resources/01.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("src/main/resources/02.txt");

        FileChannel readChannel = fileInputStream.getChannel();
        FileChannel writeChannel = fileOutputStream.getChannel();

        ByteBuffer container = ByteBuffer.allocate(4);

        // 循环读取
        for (;;){

            // 读取之前清空一下上一次的数据缓存
            container.clear();

            // 从通道中读取数据到Channel 返回值为读取数量
            int byteSize = readChannel.read(container);

            System.out.println(byteSize);

            // -1为读取完成 没有读取到任何数据
            if (byteSize == -1)
                break;
            
            if (byteSize == 3)
                System.out.println("到3了");

            // 读写切换 重置游标
            container.flip();

            // 为了避免写入空格 采用设置limit 限制
//            if(byteSize != container.capacity())
//                container.limit(byteSize);

            // 将Buffer中的数据写入到 Channel 返回值为写入的数量
            int write = writeChannel.write(container);
        }

        writeChannel.close();
        readChannel.close();
        fileOutputStream.close();
        fileInputStream.close();

    }

}

执行结果

本来还打算手动设置limit防止读取数据中的后面空格,后来在Debug的时候发现,在调用flip方法后会重新计算limit和position,所以就不需要了

案例4-拷贝文件TransferFrom方法

需求

  1. 使用FileChannel(通道)和方法 transferFrom, 完成文件的拷贝
  2. 拷贝一张图片

准备图片 01.jpeg

编码

package com.dance.netty.nio.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 使用通道实现图片拷贝
 */
public class FileChannel04 {

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

        FileInputStream fileInputStream = new FileInputStream("src/main/resources/01.jpeg");
        FileOutputStream fileOutputStream = new FileOutputStream("src/main/resources/02.jpeg");

        FileChannel sourceChannel = fileInputStream.getChannel();
        FileChannel targetChannel = fileOutputStream.getChannel();

        // 将源Channel的数据直接传输到目标Channel 从0开始 到 源的大小
        long length = targetChannel.transferFrom(sourceChannel, 0, sourceChannel.size());

        System.out.println(length);

        targetChannel.close();
        sourceChannel.close();
        fileOutputStream.close();
        fileInputStream.close();

    }

}

执行结果

ok了

关于Buffer和Channel的注意事项和细节

类型转化的get和put

ByteBuffer支持类型转化的put和get, put放入的是什么数据类型, get就应该使用相应的数据类型来取出, 否则就有可能报错(BufferUnderflowException)异常,

案例

package com.dance.netty.nio.demo;

import java.nio.ByteBuffer;

public class ByteBufferPutAndGet {

    public static void main(String[] args) {

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        buffer.putInt(1).putDouble(0.02).putLong(32312312L).putShort((short) 12).putChar('舞');

        buffer.flip();

        System.out.println(buffer.getInt());
        System.out.println(buffer.getDouble());
        System.out.println(buffer.getLong());
        System.out.println(buffer.getShort());
        System.out.println(buffer.getChar());

    }

}

执行结果

1
0.02
32312312
12
舞

将最后一个getChar类型的改为getLong类型,就会报错,所以,存入什么类型就获取什么类型,要按照顺序来

只读Buffer

可以将一个普通Buffer转成只读Buffer

编码

package com.dance.netty.nio.demo;

import java.nio.ByteBuffer;

public class ByteBufferReadOnly {

    public static void main(String[] args) {

        ByteBuffer buffer = ByteBuffer.allocate(64);

        // 写入数据
        for (byte i = 0; i < 64; i++) {
            buffer.put(i);
        }

        // 读写切换 换为只读
        buffer.flip();
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

        while (readOnlyBuffer.hasRemaining()) {
            System.out.println(readOnlyBuffer.get());
        }

        // 尝试只读Buffer写入
        // 只读 读写切换
        readOnlyBuffer.flip();

        readOnlyBuffer.put((byte) 1);

    }

}

执行结果

.......
60
61
62
63
Exception in thread "main" java.nio.ReadOnlyBufferException
    at java.nio.HeapByteBufferR.put(HeapByteBufferR.java:172)
    at com.dance.netty.nio.demo.ByteBufferReadOnly.main(ByteBufferReadOnly.java:28)

那么通过调用asReadOnlyBuffer方法返回的对象是和上面定义的Buffer是同一个类吗,会不会影响上面的Buffer

通过阅读源码可以看到,是新生成了一个HeapByteBufferR的一个新对象,所以和上面定义的对象没有任何关系

MappedByteBuffer

NIO还提供了MappedByteBuffer, 可以让文件直接在内存(堆外的内存)中进行修改, 而如何同步到文件由NIO来完成

编码

将文件02.txt中的Flower修改为Dance

package com.dance.netty.nio.demo;

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class BufferAsMappedByteBuffer {

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

        // 加载文件 权限为 rw
        RandomAccessFile randomAccessFile = new RandomAccessFile("src/main/resources/02.txt", "rw");

        FileChannel channel = randomAccessFile.getChannel();

        /*
         * FileChannel.MapMode.READ_WRITE : 模式
         * 6: 开始下标
         * 6: 从开始下标后的,修改字符数量
         */
        MappedByteBuffer map = channel.map(FileChannel.MapMode.READ_WRITE, 6, 6);

        map.put(0,(byte) 'D');
        map.put(1,(byte) 'a');
        map.put(2,(byte) 'n');
        map.put(3,(byte) 'c');
        map.put(4,(byte) 'e');
        map.put(5,(byte) ' ');

        channel.close();
        randomAccessFile.close();
        System.out.println("修改完成~~");
    }

}

执行结果

不知道为啥,好像是IDEA的索引没有更新,在IDEA中看到的是没有改变的,在文件夹中用记事本打开是已修改的

Buffer的分散和聚集

前面我们讲的读写操作,都是通过一个Buffer完成的, NIO还支持,通过多个Buffer(即Buffer数组)完成读写操作, 即Scattering和Gathering

编码

package com.dance.netty.nio.demo;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;
import java.util.stream.Stream;

public class BufferAsScatteringAndGathering {

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

        /*
         * Scattering : 将数据写入Buffer时, 可以采用Buffer数组, 依次写入 [分散]
         * Gathering : 从Buffer读取数据时, 可以采用Buffer数组, 依次读取 [聚集]
         */

        // 使用 ServerSocketChannel 和 SocketChannel

        // 获取一个ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        // 创建地址 地址默认为127.0.0.1 端口指定为 7000
        SocketAddress socketAddress = new InetSocketAddress(7000);

        // 绑定地址
        serverSocketChannel.socket().bind(socketAddress);

        // 创建Buffer数组
        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        // 第一个容量为5
        byteBuffers[0] = ByteBuffer.allocate(5);
        // 第二个容量为3
        byteBuffers[1] = ByteBuffer.allocate(3);

        System.out.println("ServerSocketChannel stating in 7000.......");

        // 阻塞并等待连接
        SocketChannel socketChannel = serverSocketChannel.accept();

        // 定义消息长度
        int messageLength = 8;

        // 循环
        for (; ; ) {

            // 读取字节大小
            int byteReadSize = 0;

            // 只有小于 指定长度 才读取
            while (byteReadSize < messageLength) {
                // 修复BUG 在读取之前调用一下clear 不然第二次读取数据 readSize 会错误
                Arrays.stream(byteBuffers).forEach(ByteBuffer::clear);

                // 从通道读取到字节数组
                long readSize = socketChannel.read(byteBuffers);
                // 累计读取字节数量
                byteReadSize += readSize;
                System.out.println("byteReadSize: " + byteReadSize);
                // 打印字节数组中的Buffer中的position和limit
                Arrays.stream(byteBuffers).map(byteBuffer -> "buffer position: " + byteBuffer.position()
                                + " buffer limit: " + byteBuffer.limit() + "\t")
                        .forEach(System.out::print);
                System.out.println();
            }

            // 将Buffer数组中的Buffer做读写切换
            Arrays.stream(byteBuffers).forEach(ByteBuffer::flip);

            // 将接收到的数据回显给客户端
            int byteWriteSize = 0;

//            if (byteWriteSize < messageLength) {
                // 将数据写回到客户端
                long writeSize = socketChannel.write(byteBuffers);
                // 累计写出字节数量
                byteWriteSize += writeSize;

                // 修复BUG 补充上面逻辑,上面要累计到8 跳出,下面如果不够的话也需要跳出所以采用while不合理,所以取消条件
//            }

            // 清空字节数组中的Buffer
            Arrays.stream(byteBuffers).forEach(ByteBuffer::clear);

            // 打印统计
            System.out.println("byteReadSize: " + byteReadSize + ", byteWriteSize: " + byteWriteSize);

        }

    }

}

执行结果

ServerSocketChannel stating in 7000.......
byteReadSize: 4
buffer position: 4 buffer limit: 5    buffer position: 0 buffer limit: 3    
byteReadSize: 9
buffer position: 5 buffer limit: 5    buffer position: 0 buffer limit: 3    
byteReadSize: 9, byteWriteSize: 5
byteReadSize: 8
buffer position: 5 buffer limit: 5    buffer position: 3 buffer limit: 3    
byteReadSize: 8, byteWriteSize: 8
byteReadSize: 8
buffer position: 5 buffer limit: 5    buffer position: 3 buffer limit: 3    
byteReadSize: 8, byteWriteSize: 8
byteReadSize: 1
buffer position: 1 buffer limit: 5    buffer position: 0 buffer limit: 3    
byteReadSize: 7
buffer position: 5 buffer limit: 5    buffer position: 1 buffer limit: 3

客户端依旧使用cmd

连接命令: Telnet 127.0.0.1 7000

ok了, 我对老师的代码进行了一些修改,有注释可以自己看一下

Selector(选择器)

基本介绍

  1. Java 的NIO, 用非阻塞的IO方式, 可以用一个线程, 处理多个的客户端连接, 就会使用到Selector(选择器)
  2. Selector能够检测多个注册的通道上是否有事件发生(注意: 多个Channel以事件的当时可以注册到同一个Selector), 如果有事件发生, 便获取事件然后针对每个事件进行相应的处理, 这样就可以只用一个单线程去管理多个通道, 也就是管理多个连接和请求[示意图]
  1. 只有在 连接/通道 真正有读写事件发生时, 才会进行读写, 就大大地减少了系统开销, 并且不必为每个连接都创建一个线程, 不用去维护多个线程
  2. 避免了多线程之间的上下文切换导致的开销

Selector示意图的特点说明

说明如下:

  1. Netty 的IO 线程 NioEventLoop 聚合了 Selector(选择器,也叫多路复用器), 可以同时并发处理成百上千个客户端连接
  2. 当线程从某客户端Socket通道进行读写数据时, 若没有数据可用时, 该线程可以进行其他任务
  1. 线程通常将非阻塞IO的空闲时间用于在其他通道上执行IO操作, 所以单独的线程可以管理多个输入和输出通道
  2. 由于读写操作都是非阻塞的, 这就可以充分提升IO线程的运行效率, 避免由于频繁的I/O 阻塞导致的线程挂起
  1. 一个I/O线程可以并发处理N个客户端连接和读写操作, 这从根本上解决了传统同步阻塞I/O一连接一线程模型, 架构的性能,弹性伸缩能力和可靠性都得到了极大的提升

Selector类相关方法

Selector类是一个抽象类, 常用方法和说明如下:

注意事项

  1. NIO中的ServerSocketChannel功能类似ServerSocket, SocketChannel功能类似Socket
  2. Select相关方法说明
    1. selector.select() // 阻塞
    2. selector.select(1000) // 阻塞1000毫秒, 在1000毫秒后返回
    1. selector.wakeup() // 唤醒selector
    2. selector.selectNow() // 不阻塞, 立马返还

NIO 非阻塞 网络编程原理分析图

NIO 非阻塞 网络编程相关的(Selector , SelectionKey , ServerSocketChannel , 和 SocketChannel) 关系梳理图

对上图的说明

  1. 当客户端连接时,会通过ServerSocketChannel 得到 SocketChannel
  2. Selector 进行监听 select 方法, 返回有事件发生的通道的个数
  1. 将SocketChannel注册到Selector上, register(Selector sel, int ops) ,一个Selector上可以注册多个SocketChannel
  2. 注册后会返回一个SelectionKey,会和该Selector关联(集合)-----[其实我觉得就是一个唯一标识]
  1. 进一步得到各个SelectionKey(有事件发生)
  2. 在通过SelectionKey反向获取SocketChannel, 方法Channel()
  1. 可以通过得到的Channel,完成业务处理
  2. 代码撑腰.....

NIO 非阻塞 网络编程快速入门

需求

  1. 编写一个NIO入门案例, 实现服务器和客户端之间的数据简单通讯(非阻塞)
  2. 目的: 理解NIO非阻塞网络编程机制

编码

编写Server

package com.dance.netty.nio.demo.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;
import java.util.Set;

public class NIOServer {

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

        // 创建ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        // 创建一个Selector
        Selector selector = Selector.open();

        // 绑定6666端口
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));

        // 设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        // 将ServerSocketChannel注册到Selector, 事件为 OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 循环等待客户端连接
        for (int i = 3; ; i+=3) {

            // 判断是否等待1秒后 无事件
            if (selector.select(3000) == 0) {
                System.out.println("等待" + i + "秒后 , 无连接");
                continue;
            }

            /*
             *  1. 如果返回大于0 代表已经获取到关注的事件 就获取相关的SelectionKey 集合
             *  2. 调用selector.selectedKeys() 返回关注事件的集合
             *  3. 通过SelectionKey反向获取Channel
             *  4. 通过Channel处理数据
             */
            Set<SelectionKey> selectionKeys = selector.selectedKeys();

            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                // 如果是连接事件
                if (selectionKey.isAcceptable()) {
                    // 因为是事件驱动的, 所以已经判断是连接事件了 在这里调用accept不会阻塞, 会立即给要连接的客户端创建一个SocketChannel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    // 将SocketChannel设置为非阻塞
                    socketChannel.configureBlocking(false);
                    // 将SocketChannel注册到Selector, 并绑定读取事件, 指定字节Buffer的大小为1024
                    SelectionKey register = socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                    System.out.println("selection key is " + register);
                }

                // 如果是读取事件
                if (selectionKey.isReadable()) {
                    // 通过SelectionKey 获取Channel
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    // 通过SelectionKey 获取ByteBuffer
                    ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                    // 将Channel的数据写入Buffer
                    socketChannel.read(buffer);

                    // 写完之后 切换为读 不然会直接读取到长度
                    buffer.flip();

                    // 不能直接使用返回的底层数组,应为会有很多空格, 需要设置偏移量和截止位置
                    System.out.println("from 客户端: " + new String(buffer.array(), 0,buffer.limit()));
                }

                // 从集合中移除Key防止重复处理
                iterator.remove();
            }
        }
    }

}

编写Client

package com.dance.netty.nio.demo.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

public class NIOClient {

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

        // 创建一个SocketChannel
        SocketChannel socketChannel = SocketChannel.open();

        // 设置非阻塞
        socketChannel.configureBlocking(false);

        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);

        // 如果没有连接成功
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要时间, 客户端不会阻塞, 可以做其他工作......");
            }
        }

        // 如果连接成功 就发数据
        String message = "Hello Flower";

        // Wraps a byte array into a buffer. (包装一个字节数组到Buffer)
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));

        int write = socketChannel.write(buffer);

        System.out.println("写入字节数: " + write);

        // 阻塞
        int read = System.in.read();
    }

}

执行结果

Server

等待3秒后 , 无连接
等待6秒后 , 无连接
selection key is sun.nio.ch.SelectionKeyImpl@29ee9faa
from 客户端: Hello Flower
等待15秒后 , 无连接
等待18秒后 , 无连接
selection key is sun.nio.ch.SelectionKeyImpl@475530b9
from 客户端: Hello Flower
等待27秒后 , 无连接
等待30秒后 , 无连接
等待33秒后 , 无连接
....

Client1 and Clent2

写入字节数: 12

在Server端,我对老师的代码进行了一些改进,在判断读事件的时候,在将Channel的数据写入Buffer后,做了读写切换,让position位置置换了limit的值,不然limit会是1024,然后再构造String的时候,设置了偏移量和截止位置,截止位置就是buffer的limit,应为做了flip, 不然会有很多空格,会将1024全部读出来

IDEA启动多客户端

我查了一下网上说是IDEA可以设置重复启动一个类的, 但是不知道为啥我的没有,我就想了一个简单的办法

拷贝一个重命名,就可以启动两个了

SelectionKey

  1. SelectionKey, 表示Selector 和网络通道的注册关系,共4种:
    1. int OP_ACCEPT: 有新的网络连接可以accept, 值为 16
    2. int OP_CONNECT: 代表连接已建立,值为8
    1. int OP_READ: 代表读操作,值为 1
    2. int OP_WRITE: 代表写操作, 值为 4
    1. 源码中:
public static final int OP READ= 1<< 0;
public static final int OP_WRITE = 1<< 2;
public static final int OP_CONNECT = l<< 3；
public static final int OP ACCEPT = 1<< 4;
  1. SelectionKey相关方法

ServerSocketChannel

  1. ServerSocketChannel在服务器端监听新的客户端Socket连接
  2. 相关方法如下

SocketChannel

  1. SocketChannel, 网络IO通道, 具体负责进行读写操作, NIO把缓冲区的数据写入通道, 或者把通道里的数据读到缓冲区
  2. 相关方法如下
十六夜之彼岸舞
关注
java nio入门
weixin_44504392的博客
11-25 499
NIO概述 JDK 1.4 java.nio 同步非阻塞 面向缓冲区（块编程） BIO\NIO和AIO BIO java.io 传统的同步阻塞式IO，线程在网络连接时会等待响应，期间不会做其他动作。 NIO java.nio from JDK1.4 同步非阻塞式io，一个线程下有一个多路选择器，他会维护多个连接。 AIO from JDK1.7 异步非阻塞IO，目前还没有什么应用 NIO三大组件 Channel 通道 Buffer 缓冲区 Selector 选择器 一个选择器对应多个通道 一个通
Java NIO2详解：异步文件和网络编程
最新发布
哎 你看的博客
06-30 983
一、NIO2 简介 从NIO到NIO2： 发展历程及优势 异步IO模型： 原理和优势 核心组件： AsynchronousChannel, CompletionHandler, AsynchronousFileChannel, AsynchronousSocketChannel/AsynchronousServerSocketChannel 二、异步文件编程 AsynchronousFileChannel： 打开、读取、写入文件 CompletionHandler： 处理异步操作结果
JAVA NIO入门实例
shanhuhau的专栏
09-14 132
[size=medium]基本概念：参考http://zhangshixi.iteye.com/blog/679959作者的系列文章即可 NIO因为其高效性，成为了服务端的首选，大大提高了服务端的响应效率。 我自己读完作者的文章，写了一个简单的DEMO 服务端：[/size] [code="java"] package com.liuc.io; import java.io.IOE...
Java NIO
八行书
03-28 660
了解java的NIO，需要先了解同步异步以及阻塞非阻塞的概念，同步/异步，阻塞/非阻塞NIO就是采用的同步非阻塞这种组合方式。或简单一点，采用的是IO复用的策略，可以使用一个线程管理多个IO连接。BIO常见使用方式传统的BIO是同步阻塞的方式，因此，在服务器中常见的使用方式是：来一个请求创建一个线程，阻塞的等待网络IO的数据。使用一个线程池，来一个请求就从线程池里取出来一个线程，阻塞的等待网络IO...
Java NIO 入门
Just Do It!
08-10 461
1.  Java NIO是什么 Java NIO（New IO）是jdk 1.4以后引入的新的IO api， 提供了不同的IO处理方式，主要有以下重要概念： Channel  和 Buffer       标准IO工作对象是字节流和字符流，主要是Stream对象。（单向，读或者写）       NIO的主要工作对象是Channel和Buffer。数据是从channel读
java Nio入门
lixin203171613的博客
01-16 213
NIO是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。在java中的全称为java non-blocking IO，它是在是从 Java 1.4 版本开始引入的一个新的IO流的API。NIO 支持面向缓冲区的、基于通道的 IO 操作。
Javajava编程从入门到大师28课+EditPlus
04-19
【Java编程从入门到大师28课+EditPlus】是一套全面且深入的Java学习资源，旨在帮助初学者快速掌握Java编程技能，并逐渐晋升为专业开发者。本套课程结合了28个精心设计的课程，涵盖了Java编程的基础概念、语法特性、...
day01-Java入门
12-12
【Java入门】 Java是一种广泛使用的高级编程语言，尤其适合于构建企业级应用程序、桌面应用、移动应用（尤其是Android平台）以及Web应用。对于初学者来说，Java具有良好的可读性和简洁的语法，使得它成为学习编程的...
Java NIO入门
03-20
Java NIO，全称为Non-Blocking Input/Output（非阻塞输入/输出），是Java标准库在1.4版本引入的一个重要特性，旨在提供一种更高效的数据处理方式，尤其是在高并发、大吞吐量的场景下。传统的Java I/O基于流(Stream)...
Java编程入门学习资料
06-02
Java编程入门学习资料是针对初学者精心准备的一套教程，旨在帮助零基础的学员快速掌握Java编程语言的基础概念和核心语法。在这个过程中，你将了解Java的历史、特点以及其广泛的应用领域，为后续深入学习打下坚实的...
java nio 入门
12-17
java nio 入门，来自于IBM中文站
java nio 入门_Java NIO 入门
weixin_35751194的博客
02-21 125
关于多路复用很多人用过InputStream和OutputStream接口，用来操作文件、Socket等等 IO 操作。如果是简单的，速度较快的 IO 操作，我们用Stream类的接口，依然可以风生水起。如果你要使用非阻塞的 IO 的话，他们可能就满足不了你了。熟悉操作系统的人会知道，操作非阻塞 IO 无非几种多路复用：selectpollepollkqueueIOCP这里的复用模型有几个是操作系...
java nio入门_Java NIO 入门
weixin_32561279的博客
02-21 143
最近接手了一个java项目，里面用到了nio。自己以前是做.net的，底子不足，所以花时间研究了一下。要点简述　nio有三个最关键的概念,通道(Channel)、选择器(Selector)和缓冲器(ByteBuffer)。通道(Channel)：这玩意说白点就是个管子，外面的数据传过来会到这个管子里，你向外发送数据的时候也得塞到这个管子里。与tcp编程相关的主要是两种通道:1. 服务器管道(Se...
Java NIO 入门学习(过门)
hlf48641715的专栏
03-19 853
Java NIO(New IO) 还是在 JDK 1.4 中引入的新特性。JDK 1.4 的另一重要特性正则表达式大家应该经常用到，但 NIO 就可能使用寥寥了，大概是缘于旧有 IO 体系仍然够用。有如 JDK1.5 早就泛型和注解了，但基于各种原因而无法亲力去实践泛型和注解一般，NIO 多数时候也只是与我们擦着肩而已。相比与 Old IO，NIO 在某些领域里确有其过人之处，所以现在让我们一起来
Java NIO入门到精通
Angelia Zheng
10-10 576
NIO(New I/O)系统，即Java的第二个I/O系统。NIO提供了与标准I/O API不同的I/O处理方式。它是Java用来替代传统I/O API(Java 1.4)。它支持面向缓冲的，基于通道的I/O操作方法。随着JDK 7的推出，NIO系统得到了扩展，为文件系统功能和文件处理提供了增强的支持。 由于NIO文件类支持的这些新的功能，NIO被广泛应用于文件处理。 NIO为Java程序员实现高...
Java NIO（一）入门篇
帅性而为1号的博客
03-31 1611
概念 java.nio（java new IO），是jdk1.4 里提供的新api ，为所有的原始类型提供缓存支持。Sun 官方标榜的特性如下： 为所有的原始类型提供(Buffer)缓存支持。字符集编码解码解决方案。 Channel ：一个新的原始I/O 抽象。 支持锁和内存映射文件的文件访问接口。 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O。 NIO和IO的主要
Java NIO快速入门
weixin_44107846的博客
06-01 238
文章目录Java NIO 基本介绍NIO 和 BIO 的比较Buffer 、 Channel 和 Selector 的关系图缓冲区（Buffer）通道(Channel)Selector(选择器)NIO 非阻塞网络编程原理分析图案例（实现服务器端和客户端之间的数据简单通讯） Java NIO 基本介绍 Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)
java nio 编程_JAVA NIO编程入门（一）
weixin_35782250的博客
02-15 148
一、前言笔者之前接触的NIO编程比较少，所以对这一块的基础也比较弱，NIO作为java编程中一个重要的模块，不能很好的掌握它，感觉自己在java方面就掌握的不够，所以，接下来，笔者会学习NIO编程，所以，该系列文章不会涉及到很深源码解析，纯粹的是学习课程，也可以理解为笔者的笔记，记录学习NIO的过程，同时也希望这类文章可以对同样想掌握NIO编程的你有帮助。二、什么是NIO？Java NIO(New...
Java NIO编程入门与实践：教程与示例
本书《Java NIO Programming Cookbook》是一本实用指南，包含了丰富的教程，适合初学者入门并深入了解NIO。书中内容涵盖了以下几个关键知识点： 1. **Java NIO基础** - **缓冲区（Buffers）**: Buffer是NIO的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值