Java-Nio知识点

最新推荐文章于 2023-11-14 00:06:11 发布

【小红帽】

最新推荐文章于 2023-11-14 00:06:11 发布

阅读量106

点赞数 2

本文链接：https://blog.csdn.net/weixin_45503113/article/details/99683639

版权

第一节：NIO简介

java.nio全称Java non-blocking IO或Java New IO，是从jdk1.4 开始引入的一套新的IO api（New IO），为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。

IO操作的模式：

PIO（Programing IO）: 所有的IO操作由CPU处理，CPU占用率比较高。

DMA(Direct Memory Access):CPU把IO操作控制权交给DMA控制器，只能以固定的方式读写，CPU空闲做其他工作。

通道方式(Channel)：能执行有限通道指令的IO控制器，代替CPU管理控制外设。通道有自己的指令系统，是一个协处理器，具有更强的独立处理数据输入和输出的能力。

Java NIO 由以下几个核心部分组成：

Buffer：缓冲区
Channel：通道
Selector：选择器(轮询器)

NIO和普通IO的区别：

第二节：Buffer的使用

Java NIO中的Buffer用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

2.1 Buffer的基本用法

使用Buffer读写数据一般遵循以下四个步骤：

创建缓冲区，写入数据到Buffer
调flip()方法
从Buffer中读取数据
调用clear()方法或者compact()方法

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。

一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

缓冲区：

import java.nio.ByteBuffer;

public class Demo {
    public static void main(String[] args) {
        //1创建缓冲区 容量1024
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        //2写入数据
        buffer.put("helloworld".getBytes());
        //3读取数据
        //3.1把写入模式，转换成读取模式
        buffer.flip();
        //3.2读取
        //单个字节读取
//        byte b = buffer.get();
//        System.out.println((char)b);
        //多个字节
        byte[] data=new byte[buffer.limit()];
        buffer.get(data);
        System.out.println(new String(data));
        //4清空
        buffer.clear();

    }
}

2.2 Buffer的capacity,position和limit

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

为了理解Buffer的工作原理，需要熟悉它的三个属性：

capacity
position
limit

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。

第三节：Channel

基本上，所有的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。

JAVA NIO中的一些主要Channel的实现：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

一、使用FileChannel复制图片

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class Copy {
    public static void main(String[] args)throws Exception {
        //创建通道
        FileChannel inchannel=FileChannel.open(Paths.get("copy.jpg"), StandardOpenOption.READ);
        FileChannel ouchannel=FileChannel.open(Paths.get("aaa.jpg"),StandardOpenOption.WRITE,StandardOpenOption.CREATE);
        //读写(创建缓冲区)
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        while (inchannel.read(buffer)>0){
            //切换模式
            buffer.flip();
            ouchannel.write(buffer);

            buffer.clear();

        }

        inchannel.close();
        ouchannel.close();


    }
}

二、使用Channel实现服务器、客户端。

服务器：

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class TcpServerChannel {
    public static void main(String[] args)throws Exception {
        //创建ServerSocketChannel
        ServerSocketChannel listener=ServerSocketChannel.open();
        //绑定
        listener.bind(new InetSocketAddress("10.9.21.177", 9999));
        //监听
        System.out.println("服务器启动了...");
        SocketChannel socketchannel = listener.accept();
        //读取
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        while (true) {
            while (socketchannel.read(buffer)>0){
                buffer.flip();// 切换为读取模式
                String data=new String(buffer.array(), 0, buffer.limit());
                System.out.println(socketchannel.getRemoteAddress()+"说："+data);
                buffer.clear();
            }
            socketchannel.close();
            listener.close();
        }
    }
}

客户端：

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

public class TcpClientChannel {
    public static void main(String[] args)throws Exception {
        // 创建socketChannel
        SocketChannel socketChannel=SocketChannel.open(new InetSocketAddress("10.9.21.177", 9999));
        //写入
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        Scanner input=new Scanner(System.in);
        while (true){
             String data=input.nextLine();
             buffer.put(data.getBytes());
             //切换模式
             buffer.flip();
             socketChannel.write(buffer); //读取
             buffer.clear();
             socketChannel.close();
        }

    }
}

第四节：Selector和非阻塞网络编程

传统的网络编程

TCP ServerSocket Socket (阻塞式)

UDP DatagramSocket DatagramPacket

4.1 ServerSocketChannel、SocketChannel实现阻塞式网络编程

ServerSocketChannel是一个基于通道的socket监听器,等同于ServerSocket类。SocketChannel是一个基于通道的客户端套接字,等同于Socket类。

4.2. Selector简介

要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。

选择器提供选择执行已经就绪的任务的能力.从底层来看，Selector提供了询问通道是否已经准备好执行每个I/O操作的能力。Selector 允许单线程处理多个Channel。仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道，这样会大量的减少线程之间上下文切换的开销。

选择器（Selector)：Selector选择器类管理着一个被注册的通道集合的信息和它们的就绪状态。通道是和选择器一起被注册的，并且使用选择器来更新通道的就绪状态。

可选择通道(SelectableChannel)：SelectableChannel这个抽象类提供了实现通道的可选择性所需要的公共方法。它是所有支持就绪检查的通道类的父类。因为FileChannel类没有继承SelectableChannel因此是不是可选通道，而所有socket通道都是可选择的，SocketChannel和ServerSocketChannel是SelectableChannel的子类。

选择键(SelectionKey)：选择键封装了特定的通道与特定的选择器的注册关系。选择键对象被SelectableChannel.register()返回并提供一个表示这种注册关系的标记。选择键包含了两个比特集(以整数的形式进行编码)，选择键支持四种操作类型：

Connect 连接
Accept 接受请求
Read 读
Write 写

实现非阻塞式网络编程：

服务器端：

public class Server {
	public static void main(String[] args) throws Exception {
		//1创建ServerSocketChannel
		ServerSocketChannel ssc=ServerSocketChannel.open();
		//2设置为非阻塞式
		ssc.configureBlocking(false);
		//3绑定地址
		ssc.bind(new InetSocketAddress("127.0.0.1",9999));
		//4创建选择器
		Selector selector=Selector.open();
		//5注册选择器
		ssc.register(selector,SelectionKey.OP_ACCEPT);
		while(selector.select()>0){
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			while(it.hasNext()){
				SelectionKey selectionKey = it.next();
				if(selectionKey.isAcceptable()){
					SocketChannel socketChannel=ssc.accept();
					socketChannel.configureBlocking(false);
					socketChannel.register(selector, selectionKey.OP_READ);
				}else if(selectionKey.isReadable()){
					//获取SocketChannel
					SocketChannel channel = (SocketChannel) selectionKey.channel();
					//创建缓冲区
					ByteBuffer buffer = ByteBuffer.allocate(1024);
					int len = 0;
					while((len = channel.read(buffer)) > 0 ){
						buffer.flip();
						System.out.println(new String(buffer.array(), 0, len));
						buffer.clear();
					}
                  	  if(len==-1){//客户端已经退出
                          channel.close();
                      }
				}
				it.remove();
			}
		}
	}
}

客户端：

public class Client {
	public static void main(String[] args) throws Exception{
		//1创建SocketChannel
		SocketChannel sc=SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
		//2设置为非阻塞式
		sc.configureBlocking(false);
		//3创建缓冲区
		ByteBuffer buffer=ByteBuffer.allocate(1024);
		Scanner input=new Scanner(System.in);
		while(input.hasNext()){
			String s=input.nextLine();
			buffer.put(s.getBytes());
			buffer.flip();
			sc.write(buffer);
			buffer.clear();
          	 if(s.equals("886")){
				break;
			}
		}
		//4关闭
		sc.close();
	}
}

【小红帽】

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-Nio知识点

第一节：NIO简介 java.nio全称Java non-blocking IO或Java New IO，是从jdk1.4 开始引入的一套新的IO api（New IO），为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。 IO操作的模式： PIO（Pro...
复制链接

扫一扫