0
点赞
收藏
分享

微信扫一扫

Java NIO用法

殇感故事 2023-03-17 阅读 51
javaSystem数据Python后端开发
加载失败


jdk1.4引入，提供分块IO操作

 

NIO即New IO,分为标准输入输出NIO,  网络编程NIO

 

标准输入输出NIO

buffer和channel是NIO的核心对象，其中数据放入buffer中，应用程序即channel必须通过buffer来读写数据。

Buffer使用步骤：

写入->调用flip()->读取->clear()/compact()方法清空

注：clear清除整个缓冲区，compact清除已读数据

-- buffer类型：Byte,Char,Double,Float,Int,Long,ShortBuffer

 

Channel用于读写数据，可看作流。

特点：双向读写，可异步读写，读写必须通过buffer

--channel类型：File、Datagram（udp）、SocketChannel(tcp)、ServerSocket(tcp连接)Channel

 

文件中读取

//1 获取通道

FileInputStream fin = new FileInputStream("E:\\hello.txt");

FileChannel fc = fin.getChannel();

//2 创建缓冲区

ByteBuffer buffer = ByteBuffer.allocate(1024);

//3 将数据从通道读到缓冲区

int res = fc.read(buffer);



写入文件

Byte[] message = new Byte[]{1, 2, 3};

//1 获取一个通道

FileOutputStream out = new FileOutputStream("E:\\hello.txt");

FileChannel fc = out.getChannel();

//2 创建缓冲区，将数据写入缓冲区

ByteBuffer buffer = ByteBuffer.allocate(1024);

for (Byte i: message) {

buffer.put(i);

}

buffer.flip();

//3 缓冲区数据写入通道

fc.write(buffer);



文件拷贝（读写结合）

//1 声明源文件和目标文件

FileInputStream fi = new FileInputStream(new File("E:\\src.txt"));

FileOutputStream fo = new FileOutputStream(new File("E:\\dst.txt"));

//2 获得传输通道channel

FileChannel inChannel = fi.getChannel();

FileChannel outChannel = fo.getChannel();

//3 获得容器buffer

ByteBuffer buffer = ByteBuffer.allocate(1024);

while (true) {

//3 判断是否读完文件

int eof = inChannel.read(buffer);

if (eof == -1) {

break;

}

//4 重设一下buffer的position=0，limit=position

buffer.flip();

//5 开始写

outChannel.write(buffer);

//6 写完要重置buffer，重设position=0,limit=capacity

buffer.clear();

}

inChannel.close();

outChannel.close();

fi.close();

fo.close();

 

注意点

无数据时，xx.read(buffer)  返回 -1。

 

网络编程NIO

NIO第三个对象Selector

Selector selector = Selector.open();

 

Selector可单线程处理多个channel，可监听IO事件的发生，可将Channel注册到selector上

但Channel必须有异步模式(FileChannel没所以不行，SocketChannel可以)，注册方法如下：

channel.configureBlocking(false);

SelectionKey key =channel.register(selector,SelectionKey.OP_READ);

 

selector四个常量(感兴趣监听的事件类型) interest set：

1. SelectionKey.OP_CONNECT

2. SelectionKey.OP_ACCEPT

3. SelectionKey.OP_READ

4. SelectionKey.OP_WRITE

注：可用  xxx | xxxx   接收多种事件。

 

判断是否interest set

int interestSet = selectionKey.interestOps();

boolean isInterestedInAccept = interestSet & SelectionKey.OP_ACCEPT;

boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;

boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;

boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;

 

判断事件就绪Ready set

selectionKey.isAcceptable();

selectionKey.isConnectable();

selectionKey.isReadable();

selectionKey.isWritable();

 

 

获取channel和selector

Channel channel = selectionKey.channel();

Selector selector = selectionKey.selector();

 

给selector附加一个对象

selectionKey.attach(theObject);

Object attachedObj = selectionKey.attachment();

或

SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

 

获取就绪channel

Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if(key.isAcceptable()) {
    // a connection was accepted by a ServerSocketChannel.
} else if (key.isConnectable()) {
    // a connection was established with a remote server.
} else if (key.isReadable()) {
    // a channel is ready for reading
} else if (key.isWritable()) {
    // a channel is ready for writing
}
keyIterator.remove();
}

 

完整例子

package test_2018_05_08;
 
import java.io.IOException;
import ​​java.net.InetSocketAddress​​;
import ​​java.net.ServerSocket​​;
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 MultiPortEcho {
    private int ports[];
    private ByteBuffer echoBuffer = ByteBuffer.allocate(1024);
 
    public MultiPortEcho(int ports[]) throws IOException {
        this.ports = ports;
        go();
    }
 
    private void go() throws IOException {
        // 1. 创建一个selector，select是NIO中的核心对象
        // 它用来监听各种感兴趣的IO事件
        Selector selector = Selector.open();
        // 为每个端口打开一个监听, 并把这些监听注册到selector中
        for (int i = 0; i < ports.length; ++i) {
            //2. 打开一个ServerSocketChannel
            //其实我们没监听一个端口就需要一个channel
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.configureBlocking(false);//设置为非阻塞
            ServerSocket ss = ssc.socket();
            InetSocketAddress address = new InetSocketAddress(ports[i]);
            ss.bind(address);//监听一个端口
            //3. 注册到selector
            //register的第一个参数永远都是selector
            //第二个参数是我们要监听的事件
            //OP_ACCEPT是新建立连接的事件
            //也是适用于ServerSocketChannel的唯一事件类型
            SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("Going to listen on " + ports[i]);
        }
        //4. 开始循环，我们已经注册了一些IO兴趣事件
        while (true) {
            //这个方法会阻塞，直到至少有一个已注册的事件发生。当一个或者更多的事件发生时
            // select() 方法将返回所发生的事件的数量。
            int num = selector.select();
            //返回发生了事件的 SelectionKey 对象的一个 集合
            Set selectedKeys = selector.selectedKeys();
            //我们通过迭代 SelectionKeys 并依次处理每个 SelectionKey 来处理事件
            //对于每一个 SelectionKey，您必须确定发生的是什么 I/O 事件，以及这个事件影响哪些 I/O 对象。
            Iterator it = selectedKeys.iterator();
            while (it.hasNext()) {
                SelectionKey key = (SelectionKey) it.next();
                //5. 监听新连接。程序执行到这里，我们仅注册了 ServerSocketChannel
                //并且仅注册它们“接收”事件。为确认这一点
                //我们对 SelectionKey 调用 readyOps() 方法，并检查发生了什么类型的事件
                if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
                    //6. 接收了一个新连接。因为我们知道这个服务器套接字上有一个传入连接在等待
                    //所以可以安全地接受它；也就是说，不用担心 accept() 操作会阻塞
                    ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    // 7. 讲新连接注册到selector。将新连接的 SocketChannel 配置为非阻塞的
                    //而且由于接受这个连接的目的是为了读取来自套接字的数据，所以我们还必须将 SocketChannel 注册到 Selector上
                    SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
                    it.remove();
                    System.out.println("Got connection from " + sc);
                } else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
                    // Read the data
                    SocketChannel sc = (SocketChannel) key.channel();
                    // Echo data
                    int bytesEchoed = 0;
                    while (true) {
                        echoBuffer.clear();
                        int r = sc.read(echoBuffer);
                        if (r <= 0) {
                            break;
                        }
                        echoBuffer.flip();
                        sc.write(echoBuffer);
                        bytesEchoed += r;
                    }
                    System.out.println("Echoed " + bytesEchoed + " from " + sc);
                    it.remove();
                }
            }
            // System.out.println( "going to clear" );
            // selectedKeys.clear();
            // System.out.println( "cleared" );
        }
    }
 
    static public void main(String args2[]) throws Exception {
        String args[] = {"9001", "9002", "9003"};
        if (args.length <= 0) {
            System.err.println("Usage: java MultiPortEcho port [port port ...]");
            System.exit(1);
        }
        int ports[] = new int[args.length];
        for (int i = 0; i < args.length; ++i) {
            ports[i] = Integer.parseInt(args[i]);
        }
        new MultiPortEcho(ports);
    }
}

 

 

 

举报

相关推荐

java nio Files.newDirectoryStream用法

javac++html系统/运维

java的NIO之UDP用法

javaUDP客户端Html/CSS前端开发

Java IO与NIO的对比与高级用法

java

java nio

java nio.netjavahtml虚拟化云计算

Java NIO

java数据字符流

Java NIO系列教程（一） Java NIO 概述

java网络Java单线程数据JavaScript前端开发

Java NIO系列教程（一） Java NIO 概述 Channel

javanioJava数据读取数据Linux系统/运维

JAVA NIO 简介

javaJAVAPython后端开发

JAVA系列：NIO

matlab开发语言人工智能信号处理

java的NIO

javaspringspring boot
0 条评论
加载失败