文档章节

JAVA NIO与IO简单对比

hgfgoodcreate
 hgfgoodcreate
发布于 2016/07/16 11:28
字数 1887
阅读 53
收藏 6

NIO和IO

NIO的四个关键数据类型

  1. Buffer:它包含数据且用于读写的线性表结构,还提供一个特殊类用于内存映射的I/O操作。
  2. Charset:提供Unicode字符串映射到字节序列以及逆映射的操作。
  3. Channels:包含socket,file和pip三种,是一种双向交通的通道。
  4. Selectors:将多元异步I/O操作集中到一个或多个线程中(类似于linux的select函数)

传统IO

服务端:

ServerSocket server = new ServerSocket(1000);
Socket conn = server.accept();
InputStream in = conn.getInputStream();
InputStreamReader reader = new BufferedReader(reader);
Request request = new Request();
while(!request.isComplete()){
	String line = reader.readLine();
	request.addLine(line);
}

上述操作有两个问题:

  1. BufferedReader类的readLine() 方法在其缓冲未满时,会一直阻塞,只有一定的数据填满缓冲或者client关闭连接,此方法才能返回。
  2. BufferedReader会产生大量的垃圾需要GC。BufferedReader需要创建缓冲区来从client读取数据,但是同样创建了一些字符串存储这些数据。

BufferedReader默认有$2^{13}$次方字符的缓冲大小。

类似的,在处理写操作时,一次写入一个字符,效率很低,也需要使用缓冲写,但是这也会插死你横更多的垃圾。

在传统的I/O中要使用大量的线程,通常使用线程池实现来处理请求。 但是即使这样,还是会有很多时间阻塞在I/O上,没有有效的利用CPU

NIO

Buffer

传统的I/O使用String来操作,浪费资源,新I/O通过使用Buffer读写数据避免浪费。

Buffer对象是线性的,有序的数据集合,他根据其类别只包含唯一的数据类型。

  • java.nio.Buffer: 类描述
  • java.nio.ByteBuffer:字节类型。可以从ReadableByteChannel中读,在WritableByteChannel中写
  • java.nio.CharBuffer:字符类型,不能写入通道
  • java.nio.DoubleBuffer:double类型,不能写入通道
  • java.nio.FloatBuffer:float类型
  • java.nio.IntBuffer:int类型
  • java.nio.LongBuffer:long类型
  • java.nio.ShortBuffer:short类型

可以使用allocate(int capacity)方法或者allocateDirect(int capacity) 方法分配一个Buffer。

特别的,可以通过调用FileChannel.map(int mode, long position, int size)创建MappedByteBuffer

Direct Buffer 在内存中分配一段连续的块并使用本地访问方法读写数据。non direct Buffer用过java中的数组读写数据。

有时间必须使用非直接的缓冲,例如使用任何wrap方法(如ButeBuffer.wrap(byte[]))在java数据自出上创建buffer。

字符编码

ByteBuffer中存放数据涉及两个问题:字节的顺序和字符转换。ByteBuffer内部通过ByteOrder类处理了字节顺序问题,但是并未解决字符转换的问题。ByteBuffer没有提供方法读写String。

java.nio.charset.Charset处理字符转换的问题。通过构造CharsetEncoder和CharsetDecoder将字符序列转为字节和逆转换。

通道

java.io类中没有一个类可以读写Buffer类型,nio提供Channel读写Buffer。channel可以认为是一种连接,可以使到特定的设备,程序或者是网络。 channel类的等级结构如下: Channel(interface)->ReadableByteChannel(interface)->ScatteringByteChannel(interface) Channel(interface)->WritableByteChannel(interface)->GatherByteChannel(interface)

ByteChannel(interface)继承自: ReadableByteChannel(interface) WritableByteChannel(interface)

GatherByteChannel可以一次将多个Buffer中的数据写入通道,相反的ScatteringByteChannel可以一次将数据从通道中读入多个buffer中。还可以设置通道使其为阻塞或非阻塞I/O操作服务。

为了使通道与传统I/O兼容,Channel提供了静态的Stream或Reader。

Selector

在过去的阻塞I/O中,我们一般知道什么时候可以向stream中读或写,因为方法调用直到stream准备好时返回。但是使用非阻塞通道,我们需要一些方法来知道什么时候通道准备好了。在NIO包中,设计Selector就是为了这个目的。

SelectableChannel可以注册特定的事件,而不是在事件发生时通知应用,通道跟踪事件。然后,当应用调用Selector上的任意一个selection方法时,它查看注册了的通道看是否有任何感兴趣的事件发生。

selector工作流程

并不是所有的通道都支持所有的操作。SelectionKey类定义了所有可能的操作位,将要用两次。

  1. 当应用调用SelectableChannel.register(Selector sel,int op)方法注册通道时,它将所需操作作为第二个参数传递到方法中。
  2. 一旦SelectionKey被选中了,SelectionKeyreadyOps()方法返回所有通道支持操作的位数的和。SelectableChannelvalidOps方法返回每个通道允许的操作。

注册通道不支持的操作将引发IllegalArgumentException异常.

SelectableChannel子类支持的操作:

ServerSocketChannel OP_ACCEPT 
SocketChannel OP_CONNECT, OP_READ, OP_WRITE 
DatagramChannel OP_READ, OP_WRITE 
Pipe.SourceChannel OP_READ 
Pipe.SinkChannel OP_WRITE

例子

  1. 简单网页内容下载
  2. 简单加法服务器和客户端
  3. 非阻塞加法服务器

简单网页下载

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

public class WebDownload {

	private final static Charset charset = Charset.forName("UTF-8");
	private SocketChannel clientChannel;

	public void download() {
		connect();
		sendRequest();
		readResponse();
	}

	//发送GET请求到CSDN的文档中心
	private void sendRequest() {
		//使用channel.write方法,它需要CharByte类型的参数,使用
		//Charset.encode(String)方法转换字符串。
		try {
			clientChannel.write(charset.encode("GET / HTTP/1.1\r\n\r\n"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	private void readResponse(){
		ByteBuffer buff = ByteBuffer.allocate(1024);//创建1024字节的缓冲
		
		try {
			// -1 if the channel has reached end-of-stream
			while(clientChannel.read(buff)!=-1){
				buff.flip();//flip方法在读缓冲区字节操作之前调用。
				
				System.out.println(charset.decode(buff));
				
				buff.clear();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private boolean connect() {
		InetSocketAddress socketAddr = new InetSocketAddress("www.baidu.com", 80);
		try {
			clientChannel = SocketChannel.open();
			clientChannel.connect(socketAddr);
			return true;
		} catch (IOException e) {
			e.printStackTrace();
		}

		return false;
	}

	public static void main(String[] args) {
		new WebDownload().download();
	}

}

简单加法服务器和客户端

server端

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


public class AddServer {
	
	private ServerSocketChannel server = null;
	private SocketChannel client = null;
	private ByteBuffer buff = ByteBuffer.allocate(8);
	private IntBuffer intBuff = buff.asIntBuffer();
	
	public void connect(){
		try {
			server = ServerSocketChannel.open();
			server.bind(new InetSocketAddress(80));
			System.out.println("channel open!");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	public void waitForConnection(){
		try {
			client = server.accept();
			if(client!=null){
				System.out.println("client connect!");
				processRequest();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void  processRequest(){
		buff.clear();
		try {
			client.read(buff);
			int result = intBuff.get(0)+intBuff.get(1);
			buff.flip();
			buff.clear();
			intBuff.put(0, result);
			client.write(buff);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}

	public void run(){
		this.connect();
		this.waitForConnection();
		this.processRequest();
	}
	/**
	 * [@param](http://my.oschina.net/u/2303379) args
	 */
	public static void main(String[] args) {
		new AddServer().run();
	}

}

client 端

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

public class AddClient {
	private SocketChannel client = null;
	private ByteBuffer buff = ByteBuffer.allocate(8);
	private IntBuffer intBuff = buff.asIntBuffer();

	public void connect() {
		try {
			client = SocketChannel.open();
			client.connect(new InetSocketAddress("localhost", 80));
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	public void request(int a, int b) {
		buff.clear();
		intBuff.put(0, a);
		intBuff.put(1, b);
		try {
			client.write(buff);
			System.out.println("send request :" + a + "+" + b);
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	public int getresult() {
		buff.clear();
		int result = 0;
		try {
			client.read(buff);
			result = buff.getInt(0);
		} catch (IOException e) {
			e.printStackTrace();
		}
		finally{
			try {
				client.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		return result;

	}
	
	public int start(int a, int b){
		this.connect();
		this.request(a, b);
		return this.getresult();
	}

	/**
	 * [@param](http://my.oschina.net/u/2303379) args
	 */
	public static void main(String[] args) {
		System.out.println(new AddClient().start(123, 345));
	}

}

非阻塞加法服务器

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


public class AddServer {
	
	private ServerSocketChannel server = null;
	private SocketChannel client = null;
	private ByteBuffer buff = ByteBuffer.allocate(8);
	private IntBuffer intBuff = buff.asIntBuffer();
	
	public void connect(){
		try {
			server = ServerSocketChannel.open();
			server.bind(new InetSocketAddress(80));
			server.configureBlocking(false);
			System.out.println("channel open!");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	public void waitForConnection(){
		Selector acceptSelector;
		try {
			acceptSelector = SelectorProvider.provider().openSelector();
			SelectionKey acceptKey = server.register(acceptSelector, SelectionKey.OP_ACCEPT);
			int keyadded = 0; 
			
			while( (keyadded = acceptSelector.select()) > 0){
				Set readyKeys = acceptSelector.selectedKeys();
				Iterator it = readyKeys.iterator();
				
				while(it.hasNext()){
					SelectionKey sk = (SelectionKey)it.next();
					it.remove();
					ServerSocketChannel nextReaedy = (ServerSocketChannel)sk.channel(); 
					client = nextReaedy.accept();
					processRequest();
				}
			}

		} catch (IOException e1) {
			e1.printStackTrace();
		}
		
	}
	
	public void  processRequest(){
		buff.clear();
		try {
			client.read(buff);
			int result = intBuff.get(0)+intBuff.get(1);
			buff.flip();
			buff.clear();
			intBuff.put(0, result);
			client.write(buff);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}

	public void run(){
		this.connect();
		this.waitForConnection();
		this.processRequest();
	}
	/**
	 * [@param](http://my.oschina.net/u/2303379) args
	 */
	public static void main(String[] args) {
		new AddServer().run();
	}

}

非阻塞的加法服务器首先通过SelectorProvider工厂方法建立选择器

acceptSelector = SelectorProvider.provider().openSelector();

然后在ServerSocketChannel上注册选择器和对应的事件。

SelectionKey acceptKey = server.register(acceptSelector, SelectionKey.OP_ACCEPT);

通过选择器获取当前是否有client连接到server:

acceptSelector.select()>0

然后将有client链接到server,获取成功连接的迭代器。遍历已经准备好的连接,分别处理请求。

© 著作权归作者所有

共有 人打赏支持
上一篇: Spring Data JPA
下一篇: git 常用总结
hgfgoodcreate
粉丝 13
博文 60
码字总数 131679
作品 0
海淀
程序员
私信 提问
分别使用Java IO、NIO、Netty实现的一个Echo Server示例

分别使用Java IO、Java NIO、Netty来实现一个简单的EchoServer(即原样返回客户端的输入信息)。 Java IO int port = 9000;ServerSocket ss = new ServerSocket(port);while (true) {final S...

zgw06629
2015/05/24
0
0
Tomcat的BIO、NIO、APR模式对比与性能测试结果

11.11活动当天,服务器负载过大,导致部分页面出现了不可访问的状态、那后来就要求调优了,下面是tomcat bio、nio、apr模式以及后来自己测试的一些性能结果。 原理方面的资料都是从网上找的,...

DemonsI
02/15
0
0
Qzone 微信 Java高级——dubbo源码分析之远程通信 netty

Java高级——dubbo源码分析之远程通信 netty dubbo 底层通信选择了 netty 这个 nio 框架做为默认的网络通信框架并且通过自定义协议进行通信。dubbo 支持以下网络通信框架: Netty(默认) Min...

Java架构师那些事
2018/08/29
0
0
JAVA NIO编程入门(一)

JAVA NIO编程入门(一) 一、前言 笔者之前接触的NIO编程比较少,所以对这一块的基础也比较弱,NIO作为java编程中一个重要的模块,不能很好的掌握它,感觉自己在java方面就掌握的不够,所以,...

木木匠
2018/09/01
0
0
使用J2SE进行服务器架构技术选型的变迁

虽然现在对大多数程序员来讲,基本不会再有使用Java开发一个服务器这样的任务,但是,这方面的技术研究一下,对自己的技术提高还是非常有帮助的。说不定啥时候能派上用场。 使用Java(J2SE)...

webas
2013/04/26
0
0

没有更多内容

加载失败,请刷新页面

加载更多

C++ vector和list的区别

1.vector数据结构 vector和数组类似,拥有一段连续的内存空间,并且起始地址不变。 因此能高效的进行随机存取,时间复杂度为o(1); 但因为内存空间是连续的,所以在进行插入和删除操作时,会造...

shzwork
今天
3
0
Spring之invokeBeanFactoryPostProcessors详解

Spring的refresh的invokeBeanFactoryPostProcessors,就是调用所有注册的、原始的BeanFactoryPostProcessor。 相关源码 public static void invokeBeanFactoryPostProcessors(Configu......

cregu
昨天
4
0
ibmcom/db2express-c_docker官方使用文档

(DEPRECIATED) Please check DB2 Developer-C Edition for the replacement. What is IBM DB2 Express-C ? ``IBM DB2 Express-C``` is the no-charge community edition of DB2 server, a si......

BG2KNT
昨天
3
0
Ubuntu 18.04.2 LTS nvidia-docker2 : 依赖: docker-ce (= 5:18.09.0~3-0~ubuntu-bionic)

平台:Ubuntu 18.04.2 LTS nvidia-docker2 版本:2.0.3 错误描述:在安装nvidia-docker2的时候报dpkg依赖错误 nvidia-docker2 : 依赖: docker-ce (= 5:18.09.0~3-0~ubuntu-bionic) 先看一下依......

Pulsar-V
昨天
4
0
学习笔记1-goland结构体(struct)

写在前面:若有侵权,请发邮件by.su@qq.com告知。 转载者告知:如果本文被转载,但凡涉及到侵权相关事宜,转载者需负责。请知悉! 本文永久更新地址:https://my.oschina.net/bysu/blog/3036...

不最醉不龟归
昨天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部