衣带渐宽终不悔。为伊消得人憔悴。
——柳永《蝶恋花》
Java NIO
1. Java NIO 简介
Java NIO(New IO)是从Java 1.4
版本开始引入的一个新的IO API,可以替代标准的Java IO API。 NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同,NIO支持面向缓冲区的、基于通道的IO操作。
NIO将以更加高效的方式进行文件的读写操作。
2. Java NIO 与 IO 的主要区别
IO |
NIO |
面向流(Stream Oriented) |
面向缓冲区(Buffer Oriented) |
阻塞IO(Blocking IO) |
非阻塞IO(Non Blocking IO) |
(无) |
选择器(Selectors) |
3. 缓冲区(Buffer)和通道(Channel)
Java NIO系统的核心在于:通道(Channel)和缓冲区(Buffer)。
通道表示打开到IO 设备(例如:文件、套接字)的连接。若需要使用NIO 系统,需要获取用于连接IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区,对数据进行处理。
==简而言之,Channel 负责传输,Buffer 负责存储。==
3.1 缓冲区(Buffer)
缓冲区(Buffer):
一个用于特定基本数据类型的容器
。由java.nio 包
定义的,所有缓冲区都是Buffer 抽象类的子类。
Java NIO 中的Buffer 主要用于与NIO 通道进行交互
,数据是从通道读入缓冲区,从缓冲区写入通道中的。
Buffer 就像一个数组
,可以保存多个相同类型的数据。根据数据类型不同(boolean 除外) ,有以下Buffer 常用子类:
- ByteBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
- CharBuffer
上述Buffer 类他们都采用相似的方法进行管理数据,只是各自管理的数据类型不同而已。都是通过如下方法获取一个Buffer 对象:public static XxxBuffer allocate(int capacity)
: 创建一个容量为capacity 的XxxBuffer 对象,具体如下:
public static IntBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapIntBuffer(capacity, capacity);
}
缓冲区的基本属性
Buffer 中的重要概念:
容量(capacity)
: 表示缓冲区中最大存储数据的容量。一旦声明不能改变。
限制(limit)
:表示缓冲区中可以操作数据的大小。(limit 后数据不能进行读写)
位置(position)
:表示缓冲区中正在操作数据的位置。
标记(mark):
表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置。
标记、位置、限制、容量遵守以下不变式: 0 <= mark <= position <= limit <= capacity
缓冲区存取数据的两个核心方法
- put() : 存入数据到缓冲区中
put(byte b):
将给定单个字节写入缓冲区的当前位置。
put(byte[] src):
将src 中的字节写入缓冲区的当前位置。
put(int index, byte b):
将指定字节写入缓冲区的索引位置(不会移动position)。
- get() : 获取缓冲区中的数据
get() :
读取单个字节。
get(byte[] dst):
批量读取多个字节到dst 中。
get(int index):
读取指定索引位置的字节(不会移动position)。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
| package cn.justweb;
import org.junit.Test;
import java.nio.ByteBuffer;
public class BufferTest {
@Test public void test1(){ String str = "abcde"; ByteBuffer buf = ByteBuffer.allocate(1024);
System.out.println("-----------------allocate()----------------"); System.out.println(buf.position()); System.out.println(buf.limit()); System.out.println(buf.capacity());
buf.put(str.getBytes());
System.out.println("-----------------put()----------------"); System.out.println(buf.position()); System.out.println(buf.limit()); System.out.println(buf.capacity());
buf.flip(); System.out.println("-----------------flip()----------------"); System.out.println(buf.position()); System.out.println(buf.limit()); System.out.println(buf.capacity());
byte[] dst = new byte[buf.limit()]; buf.get(dst); System.out.println(new String(dst, 0, dst.length));
System.out.println("-----------------get()----------------"); System.out.println(buf.position()); System.out.println(buf.limit()); System.out.println(buf.capacity());
buf.rewind();
System.out.println("-----------------rewind()----------------"); System.out.println(buf.position()); System.out.println(buf.limit()); System.out.println(buf.capacity());
buf.clear();
System.out.println("-----------------clear()----------------"); System.out.println(buf.position()); System.out.println(buf.limit()); System.out.println(buf.capacity());
System.out.println((char)buf.get()); }
@Test public void test2(){ String str = "abcde"; ByteBuffer buf = ByteBuffer.allocate(1024); buf.put(str.getBytes()); buf.flip(); byte[] dst = new byte[buf.limit()]; buf.get(dst,0,2);
System.out.println(new String(dst,0,2)); System.out.println(buf.position());
buf.mark();
buf.get(dst,2,2);
System.out.println(new String(dst,2,2));
System.out.println(buf.position()); buf.reset(); System.out.println(buf.position()); if(buf.hasRemaining()){ System.out.println(buf.remaining()); }
} }
|
直接缓冲区与非直接缓冲区
1 2 3 4 5 6 7 8 9 10
| public class TestBuffer { @Test public void test3(){ ByteBuffer buf = ByteBuffer.allocateDirect(1024); System.out.println(buf.isDirect()); } }
|
- 字节缓冲区要么是直接的,要么是非直接的。如果为直接字节缓冲区,则Java 虚拟机会尽最大努力直接在此缓冲区上执行本机I/O 操作。也就是说,在每次调用基础操作系统的一个本机I/O 操作之前(或之后),虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中(或从中间缓冲区中复制内容)。
- ☆直接字节缓冲区可以通过调用此类的
allocateDirect() 工厂方法
来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区
。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外,因此,它们对应用程序的内存需求量造成的影响可能并不明显。所以,建议将直接缓冲区主要分配给那些易受基础系统的本机I/O 操作影响的大型、持久的缓冲区
。一般情况下,最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
- ☆直接字节缓冲区还可以
通过FileChannel 的map() 方法
将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer
。Java 平台的实现有助于通过JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域,则试图访问该区域不会更改该缓冲区的内容,并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。
- 字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其
isDirect() 方法
来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。
3.2 通道(Channel)
通道(Channel):由java.nio.channels 包定义的
。Channel 表示IO 源与目标打开的连接
。 Channel 类似于传统的“流”。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据,因此需要配合缓冲区进行传输。
- 什么是DMA
- DMA 和 Channel 的区别
Channel 接口的最主要实现类
java.nio.channels.Channel 接口:
FileChannel:
用于读取、写入、映射和操作文件的通道。
DatagramChannel:
通过 UDP 读写网络中的数据通道。
SocketChannel:
通过 TCP 读写网络中的数据。
ServerSocketChannel:
可以监听新进来的 TCP 连接,对每一个新进来的链接都会创建一个SocketChannel。
获取通道的三种方式
Java 针对支持通道的类提供了 getChannel() 方法。
- 本地 IO:
- FileInputStream/FileOutputStream
- RandomAccessFile
- 网络IO:
- Socket
- ServerSocket
- DatagramSocket
在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()
。
在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()。
通道之间的数据传输☆
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
|
@Test public void test1(){ long start = System.currentTimeMillis();
FileInputStream fis = null; FileOutputStream fos = null; FileChannel inChannel = null; FileChannel outChannel = null; try {
fis = new FileInputStream("E:\\file\\1988第一段.mp4"); fos = new FileOutputStream("E:\\file\\1988-copy1.mp4"); inChannel = fis.getChannel(); outChannel = fos.getChannel();
ByteBuffer buf = ByteBuffer.allocate(1024); while(inChannel.read(buf) != -1){ buf.flip(); outChannel.write(buf); buf.clear(); } } catch (IOException e) { e.printStackTrace(); }finally { try { outChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { inChannel.close(); } catch (IOException e) { e.printStackTrace(); }
try { fos.close(); } catch (IOException e) { e.printStackTrace(); } try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } }
@Test public void test2(){ long start = 0; long end = 0; FileChannel inChannel = null; FileChannel outChannel = null; MappedByteBuffer inMappedBuf = null; MappedByteBuffer outMappedBuf = null;
try { start = System.currentTimeMillis();
inChannel = FileChannel.open(Paths.get("E:\\file\\1988第一段.mp4"), StandardOpenOption.READ); outChannel = FileChannel.open(Paths.get("E:\\file\\1988-copy2.mp4"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
inMappedBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size()); outMappedBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());
byte[] dst = new byte[inMappedBuf.limit()]; inMappedBuf.get(dst); outMappedBuf.put(dst);
} catch (IOException e) { e.printStackTrace(); }finally { try { inChannel.close(); outChannel.close(); } catch (IOException e) { e.printStackTrace(); } end = System.currentTimeMillis(); System.out.println("耗费时间为:" + (end - start)); } }
|
分散(Scatter)与聚集(Gather)
- 分散读取(Scattering Reads):将通道中的数据分散到多个缓冲区中。
- 聚集写入(Gathering Writes):将多个缓冲区中的数据聚集到通道中。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
|
@Test public void test4(){ RandomAccessFile raf1 = null; RandomAccessFile raf2= null; FileChannel channel1 = null; FileChannel channel2 = null; try { raf1 = new RandomAccessFile("1.txt", "rw"); channel1 = raf1.getChannel(); ByteBuffer buf1 = ByteBuffer.allocate(100); ByteBuffer buf2 = ByteBuffer.allocate(1024);
ByteBuffer[] bufs = {buf1,buf2}; channel1.read(bufs);
for (ByteBuffer buf : bufs) { buf.flip(); } System.out.println(new String(bufs[0].array(),0,bufs[0].limit())); System.out.println("---------------------------------------------"); System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
raf2 = new RandomAccessFile("2.txt", "rw"); channel2 = raf2.getChannel(); channel2.write(bufs); } catch (IOException e) { e.printStackTrace(); }finally { try { channel2.close(); } catch (IOException e) { e.printStackTrace(); } try { raf2.close(); } catch (IOException e) { e.printStackTrace(); } try { channel1.close(); } catch (IOException e) { e.printStackTrace(); } try { raf1.close(); } catch (IOException e) { e.printStackTrace(); } } }
|
transferFrom()和transferTo()
transferFrom()
将数据从源通道传输到其他 Channel 中。
transferTo()
将数据从源通道传输到其他 Channel 中。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
|
@Test public void test3(){ FileChannel inChannel = null; FileChannel outChannel = null; try { inChannel = FileChannel.open(Paths.get("E:\\file\\1988第一段.mp4"), StandardOpenOption.READ); outChannel = FileChannel.open(Paths.get("E:\\file\\1988-copy3.mp4"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE); outChannel.transferFrom(inChannel,0,inChannel.size());
} catch (IOException e) { e.printStackTrace(); }finally { try { inChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { outChannel.close(); } catch (IOException e) { e.printStackTrace(); } } }
|
字符集:Charset
- 编码:字符串 -> 字节数组
- 解码:字节数组 -> 字符串
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
|
@Test public void test5(){ try { Charset cs1 = Charset.forName("GBK"); CharsetEncoder ce = cs1.newEncoder(); CharsetDecoder cd = cs1.newDecoder(); CharBuffer cBuf = CharBuffer.allocate(1024); cBuf.put("Justweb程序员"); cBuf.flip(); ByteBuffer bBuf = ce.encode(cBuf); for (int i = 0; i < 13; i++) { System.out.println(bBuf.get()); }
bBuf.flip(); CharBuffer cBuf2 = cd.decode(bBuf); System.out.println(cBuf2.toString()); System.out.println("----------------------------"); Charset cs2 = Charset.forName("UTF-8"); bBuf.flip(); CharBuffer cBuf3 = cs2.decode(bBuf); System.out.println(cBuf3.toString());
} catch (CharacterCodingException e) { e.printStackTrace(); } }
|
FileChannel 的常用方法
4. NIO 的非阻塞式网络通信
4.1 阻塞与非阻塞
传统的IO 流都是阻塞式的。
也就是说,当一个线程调用read() 或write()时,该线程被阻塞,直到有一些数据被读取或写入,该线程在此期间不能执行其他任务。因此,在完成网络通信进行IO 操作时,由于线程会阻塞,所以服务器端必须为每个客户端都提供一个独立的线程进行处理,当服务器端需要处理大量客户端时,性能急剧下降。
Java NIO 是非阻塞模式的。
当线程从某通道进行读写数据时,若没有数据可用时,该线程可以进行其他任务。线程通常将非阻塞IO 的空闲时间用于在其他通道上执行IO 操作,所以单独的线程可以管理多个输入和输出通道。因此,NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。
-
SocketChannel
- Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。
- 操作步骤:
- 打开SocketChannel
- 读写数据
- 关闭SocketChannel
- Java NIO中的ServerSocketChannel 是一个可以监听新进来的TCP连接的通道,就像标准IO中的ServerSocket一样。
DatagramChannel
- Java NIO中的DatagramChannel是一个能收发UDP包的通道。
- 操作步骤:
- 打开DatagramChannel
- 接收/发送数据
阻塞模式
使用 NIO 完成网络通信的三个核心:
通道(Channel):负责连接
|--Pipe.SinkChannel
|--Pipe.SourceChannel
缓冲区(Buffer):负责数据的存取。
选择器(Selector):是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况。
- Java中InetAddress与InetSocketAddress的基本用法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
| package cn.justweb;
import org.junit.Test;
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.file.Paths; import java.nio.file.StandardOpenOption;
public class BlockingNIOTest {
@Test public void client(){ SocketChannel sChannel = null; FileChannel inChannel = null; try { sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 1021)); inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
ByteBuffer buf = ByteBuffer.allocate(1024);
while (inChannel.read(buf) != -1){ buf.flip(); sChannel.write(buf); buf.clear(); } } catch (IOException e) { e.printStackTrace(); }finally { try { inChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { sChannel.close(); } catch (IOException e) { e.printStackTrace(); } } }
@Test public void server(){ ServerSocketChannel ssChannel = null; FileChannel outChannel = null; SocketChannel sChannel = null; try { ssChannel = ServerSocketChannel.open(); outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
ssChannel.bind(new InetSocketAddress(1021)); sChannel = ssChannel.accept(); ByteBuffer buf = ByteBuffer.allocate(1024); while(sChannel.read(buf) != -1){ buf.flip(); outChannel.write(buf); buf.clear(); } } catch (IOException e) { e.printStackTrace(); }finally { try { sChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { outChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { ssChannel.close(); } catch (IOException e) { e.printStackTrace(); } }
} }
|
BlockingNIO2Test
:完成阻塞时双向通信。
sChannel.shutdownOutput();
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
| package cn.justweb;
import org.junit.Test;
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.file.Paths; import java.nio.file.StandardOpenOption;
public class BlockingNIO2Test {
@Test public void client() { SocketChannel sChannel = null; FileChannel inChannel = null; try { sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 1021)); inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ); ByteBuffer buf = ByteBuffer.allocate(1024); while (inChannel.read(buf) != -1) { buf.flip(); sChannel.write(buf); buf.clear(); } sChannel.shutdownOutput(); int len = 0; while ((len = sChannel.read(buf)) != -1) { buf.flip(); System.out.println(new String(buf.array(), 0, len)); buf.clear(); } } catch (IOException e) { e.printStackTrace(); } finally { try { inChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { sChannel.close(); } catch (IOException e) { e.printStackTrace(); } } }
@Test public void server() { ServerSocketChannel ssChannel = null; FileChannel outChannel = null; SocketChannel sChannel = null; try { ssChannel = ServerSocketChannel.open();
outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
ssChannel.bind(new InetSocketAddress(1021));
sChannel = ssChannel.accept();
ByteBuffer buf = ByteBuffer.allocate(1024);
while (sChannel.read(buf) != -1) { buf.flip(); outChannel.write(buf); buf.clear(); } buf.put("服务端接收数据成功".getBytes()); buf.flip(); sChannel.write(buf); } catch (IOException e) { e.printStackTrace(); } finally { try { sChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { outChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { ssChannel.close(); } catch (IOException e) { e.printStackTrace(); } } }
}
|
非阻塞模式
解决junit测试的时候,不能在控制台进行输入
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
| package cn.justweb;
import org.junit.Test;
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*;
import java.util.Date; import java.util.Iterator; import java.util.Scanner;
public class NonBlockingNIOTest {
@Test public void client() { SocketChannel sChannel = null; try { sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 1021));
sChannel.configureBlocking(false);
ByteBuffer buf = ByteBuffer.allocate(1024);
Scanner scan = new Scanner(System.in); while (scan.hasNext()) { String str = scan.next(); buf.put((new Date().toString() + "\n" + str).getBytes()); buf.flip(); sChannel.write(buf); buf.clear(); } } catch (IOException e) { e.printStackTrace(); } finally { try { sChannel.close(); } catch (IOException e) { e.printStackTrace(); } } }
@Test public void server() { ServerSocketChannel ssChannel = null; try { ssChannel = ServerSocketChannel.open(); ssChannel.configureBlocking(false);
ssChannel.bind(new InetSocketAddress(1021));
Selector selector = Selector.open();
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() > 0) { Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) { SelectionKey sk = it.next(); if (sk.isAcceptable()) { SocketChannel sChannel = ssChannel.accept();
sChannel.configureBlocking(false);
sChannel.register(selector, SelectionKey.OP_READ); } else if (sk.isReadable()) {
SocketChannel sChannel = (SocketChannel) sk.channel();
ByteBuffer buf = ByteBuffer.allocate(1024);
int len = 0; while ((len = sChannel.read(buf)) > 0) { buf.flip(); System.out.println(new String(buf.array(), 0, len)); buf.clear(); } }
it.remove(); } } } catch (IOException e) { e.printStackTrace(); } finally { try { ssChannel.close(); } catch (IOException e) { e.printStackTrace(); } }
} }
|
NonBlockingNIO2Test
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
| package cn.justweb;
import org.junit.Test;
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.DatagramChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.util.Date; import java.util.Iterator; import java.util.Scanner;
public class NonBlockingNIO2Test {
@Test public void send() { DatagramChannel dc = null; try { dc = DatagramChannel.open(); dc.configureBlocking(false); ByteBuffer buffer = ByteBuffer.allocate(1024); Scanner scan = new Scanner(System.in);
while (scan.hasNext()) { String str = scan.next(); buffer.put((new Date() + "\n" + str).getBytes()); buffer.flip(); dc.send(buffer, new InetSocketAddress("127.0.0.1", 1021)); buffer.clear(); } } catch (IOException e) { e.printStackTrace(); } finally { try { dc.close(); } catch (IOException e) { e.printStackTrace(); } } }
@Test public void receive() { DatagramChannel dc = null; try { dc = DatagramChannel.open(); dc.configureBlocking(false); dc.bind(new InetSocketAddress(1021)); Selector selector = Selector.open(); dc.register(selector, SelectionKey.OP_READ); while (selector.select() > 0) { Iterator<SelectionKey> it = selector.selectedKeys().iterator(); while (it.hasNext()) { SelectionKey sk = it.next(); if (sk.isReadable()) { ByteBuffer buffer = ByteBuffer.allocate(1024); dc.receive(buffer); buffer.flip(); System.out.println(new String(buffer.array(), 0, buffer.limit())); buffer.clear(); } } it.remove(); } } catch (IOException e) { e.printStackTrace(); } } }
|
4.2 选择器(Selector)
选择器(Selector)
是SelectableChannle 对象的多路复用器,Selector 可以同时监控多个SelectableChannel 的IO 状况,也就是说,利用Selector可使一个单独的线程管理多个Channel。Selector 是非阻塞IO 的核心。
SelectableChannle 的结构如下图:
- 通过调用Selector.open() 方法创建一个Selector。
- 向选择器注册通道:
SelectableChannel.register(Selector sel,int ops);
当调用register(Selector sel, int ops) 将通道注册选择器时,选择器对通道的监听事件,需要通过第二个参数ops 指定。
- 可以监听的事件类型(可使用SelectionKey 的四个常量表示):
读: SelectionKey.OP_READ (1)
写: SelectionKey.OP_WRITE (4)
连接: SelectionKey.OP_CONNECT (8)
接收: SelectionKey.OP_ACCEPT (16)
SelectionKey:表示SelectableChannel 和Selector 之间的注册关系。
每次向选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。下面是SelectionKey的常用方法:
4.3 管道
Java NIO 管道是2个线程之间的单向数据连接。 Pipe有一个source通道和一个sink通道。数据会被写到sink通道,从source通道读取。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
|
public class PipeTest {
@Test public void test() { Pipe.SinkChannel sinkChannel = null; Pipe.SourceChannel sourceChannel = null; try { Pipe pipe = Pipe.open();
ByteBuffer buffer = ByteBuffer.allocate(1024); sinkChannel = pipe.sink(); buffer.put("通过单向通道发送数据".getBytes()); buffer.flip(); sinkChannel.write(buffer);
sourceChannel = pipe.source(); buffer.flip(); int len = sourceChannel.read(buffer); System.out.println(new String(buffer.array(), 0, len)); } catch (IOException e) { e.printStackTrace(); } finally { try { sourceChannel.close(); } catch (IOException e) { e.printStackTrace(); } try { sinkChannel.close(); } catch (IOException e) { e.printStackTrace(); } }
} }
|
5. NIO.2
随着JDK 7 的发布,Java对NIO进行了极大的扩展,增强了对文件处理和文件系统特性的支持,以至于我们称他们为NIO.2。因为NIO 提供的一些功能,NIO已经成为文件处理中越来越重要的部分。
5.1 Path和Paths
java.nio.file.Path 接口代表一个平台无关的平台路径,描述了目录结构中文件的位置。
Paths 提供的get() 方法用来获取Path 对象:
Path get(String first, String … more) : 用于将多个字符串串连成路径。
Path 常用方法: |
boolean endsWith(String path) : 判断是否以 path 路径结束 |
boolean startsWith(String path) : 判断是否以 path 路径开始 |
boolean isAbsolute() : 判断是否是绝对路径 |
Path getFileName() : 返回与调用 Path 对象关联的文件名 |
Path getName(int idx) : 返回的指定索引位置 idx 的路径名称 |
int getNameCount() : 返回Path 根目录后面元素的数量 |
Path getParent() : 返回Path对象包含整个路径,不包含 Path 对象指定的文件路径 |
Path getRoot() : 返回调用 Path 对象的根路径 |
Path resolve(Path p) : 将相对路径解析为绝对路径 |
Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象 |
String toString() : 返回调用 Path 对象的字符串表示形式 |
5.2 Files 类
- Java基础之File类
- java.nio.file.Files用于操作文件或目录的
工具类。
Files常用方法:
Path copy(Path src, Path dest, CopyOption … how) : 文件的复制 |
Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录 |
Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件 |
void delete(Path path) : 删除一个文件 |
Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置 |
long size(Path path) : 返回 path 指定文件的大小 |
Files常用方法:用于判断
boolean exists(Path path, LinkOption … opts) : 判断文件是否存在 |
boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录 |
boolean isExecutable(Path path) : 判断是否是可执行文件 |
boolean isHidden(Path path) : 判断是否是隐藏文件 |
boolean isReadable(Path path) : 判断文件是否可读 |
boolean isWritable(Path path) : 判断文件是否可写 |
boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在 |
public static A readAttributes(Path path,Class type,LinkOption… options) : 获取与 path 指定的文件相关联的属性。 |
Files常用方法:用于操作内容
SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接,how 指定打开方式。 |
DirectoryStream newDirectoryStream(Path path) : 打开 path 指定的目录 |
InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象 |
OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象 |
5.3 自动资源管理
Java 7 增加了一个新特性,该特性提供了另外一种管理资源的方式,这种方式能自动关闭文件。这个特性有时被称为自动资源管理(Automatic Resource Management, ARM),该特性以try 语句的扩展版为基础。自动资源管理主要用于,当不再需要文件(或其他资源)时,可以防止无意中忘记释放它们。
☆