package com.java.xiong.Net17;
成都创新互联公司专注于涟水网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供涟水营销型网站建设，涟水网站制作、涟水网页设计、涟水网站官网定制、小程序开发服务，打造涟水网络公司原创品牌,更为您提供涟水网站排名全网营销落地服务。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
public class NServer {
// 用于检测所有的Channel状态的selector
private Selector selector = null;
static final int PORT = 30000;
// 定义实现编码、解码的字符串集对象
private Charset charse = Charset.forName("GBK");
public void init() throws IOException {
selector = Selector.open();
// 通过open方法来打开一个未绑定的ServerSocketChannel是咧
ServerSocketChannel server = ServerSocketChannel.open();
InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);
// 将该ServerSocketChannel绑定到指定的IP地址
server.bind(isa);
// 设置serverSocket已非阻塞方式工作
server.configureBlocking(false);
// 将server注册到指定的selector对象
server.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() 0) {
// 一次处理selector上的每个选择的SelectionKey
for (SelectionKey sk : selector.selectedKeys()) {
// 从selector上已选择的Kye集中删除正在处理的SelectionKey
selector.selectedKeys().remove(sk);
// 如果sk对应的Channel包含客户端的连接请求
if (sk.isAcceptable()) {
// 调用accept方法接收连接，产生服务器段的SocketChennal
SocketChannel sc = server.accept();
// 设置采用非阻塞模式
sc.configureBlocking(false);
// 将该SocketChannel注册到selector
sc.register(selector, SelectionKey.OP_READ);
}
// 如果sk对应的Channel有数据需要读取
if (sk.isReadable()) {
// 获取该SelectionKey对银行的Channel，该Channel中有刻度的数据
SocketChannel sc = (SocketChannel) sk.channel();
// 定义备注执行读取数据源的ByteBuffer
ByteBuffer buff = ByteBuffer.allocate(1024);
String content = "";
// 开始读取数据
try {
while (sc.read(buff) 0) {
buff.flip();
content += charse.decode(buff);
}
System.out.println("读取的数据：" + content);
// 将sk对应的Channel设置成准备下一次读取
sk.interestOps(SelectionKey.OP_READ);
}
// 如果捕获到该sk对银行的Channel出现了异常，表明
// Channel对应的Client出现了问题，所以从Selector中取消
catch (IOException io) {
// 从Selector中删除指定的SelectionKey
sk.cancel();
if (sk.channel() != null) {
sk.channel().close();
}
}
// 如果content的长度大于0,则连天信息不为空
if (content.length() 0) {
// 遍历selector里注册的所有SelectionKey
for (SelectionKey key : selector.keys()) {
// 获取该key对应的Channel
Channel targerChannel = key.channel();
// 如果该Channel是SocketChannel对象
if (targerChannel instanceof SocketChannel) {
// 将读取到的内容写入该Channel中
SocketChannel dest = (SocketChannel) targerChannel;
dest.write(charse.encode(content));
}
}
}
}
}
}
}
public static void main(String [] args) throws IOException{
new NServer().init();
}
}
nio引入了buffer、channel、selector等概念。
通道相当于之前的I/O流。
“通道”太抽象了。java解释不清的东西只能看它底层是怎么解释的——操作系统的I/O控制，通道控制方式？
I/O设备：CPU——通道——设备控制器——I/O设备
（通道和设备控制器的关系是多对多，设备控制器和I/O设备的关系也是多对多。）
I/O过程，参考;DMA.htm：
1.CPU在执行用户程序时遇到I/O请求，根据用户的I/O请求生成通道程序（也可以是事先编好的）。放到内存中，并把该通道程序首地址放入CAW中。
2.CPU执行“启动I/O”指令，启动通道工作。
3.通道接收“启动I/O”指令信号，从CAW（记录下一条通道指令存放的地址）中取出通道程序首地址，并根据此地址取出通道程序的第一条指令，放入CCW（记录正在执行的通道指令）中；同时向CPU发回答信号，通知“启动I/O”指令完成完毕，CPU可继续执行。
4.与此同时，通道开始执行通道程序，进行物理I/O操作。当执行完一条指令后，如果还有下一条指令则继续执行；否则表示传输完成，同时自行停止，通知CPU转去处理通道结束事件，并从CCW中得到有关通道状态。
如此一来，主处理器只要发出一个I/O操作命令，剩下的工作完全由通道负责。I/O操作结束后，I/O通道会发出一个中断请求，表示相应操作已完成。
通道控制方式是对数据块进行处理的，并非字节。
通道控制方式就是异步I/O，参考：
I/O分两段：1.数据从I/O设备到内核缓冲区。2.数据从内核缓冲区到应用缓冲区
I/O类型：
1.异步I/O不会产生阻塞，程序不会等待I/O完成，继续执行代码，等I/O完成了再执行一个什么回调函数，代码执行效率高。很容易联想到ajax。这个一般用于I/O操作不影响之后的代码执行。
2.阻塞I/O，程序发起I/O操作后，进程阻塞，CPU转而执行其他进程，I/O的两个步骤完成后，向CPU发送中断信号，进程就绪，等待执行。
3.非阻塞I/O并非都不阻塞，其实是第一步不阻塞，第二部阻塞。程序发起I/O操作后，进程一直检查第一步是否完成，CPU一直在循环询问，完成后，进程阻塞直到完成第二步。明白了！这个是“站着茅坑不拉屎”，CPU利用率最低的。逻辑和操作系统的程序直接控制方式一样。
阻塞不阻塞描述的是发生I/O时当前线程的状态。
以上是操作系统的I/O，那么java的nio又是怎样的呢？
个人觉得是模仿了通道控制方式。
先看看nio的示例代码：
服务端TestReadServer.java
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 TestReadServer { /*标识数字*/ private int flag = 0; /*缓冲区大小*/ private int BLOCK = 1024*1024*10; /*接受数据缓冲区*/ private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*发送数据缓冲区*/ private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); private Selector selector; public TestReadServer(int port) throws IOException { // 打开服务器套接字通道 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); // 服务器配置为非阻塞 serverSocketChannel.configureBlocking(false); // 检索与此通道关联的服务器套接字 ServerSocket serverSocket = serverSocketChannel.socket(); // 进行服务的绑定 serverSocket.bind(new InetSocketAddress(port)); // 通过open()方法找到Selector selector = Selector.open(); // 注册到selector，等待连接 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.println("Server Start----"+port+":"); } // 监听 private void listen() throws IOException { while (true) { // 选择一组键，并且相应的通道已经打开 selector.select(); // 返回此选择器的已选择键集。 SetSelectionKey selectionKeys = selector.selectedKeys(); IteratorSelectionKey iterator = selectionKeys.iterator(); while (iterator.hasNext()) { SelectionKey selectionKey = iterator.next(); iterator.remove(); handleKey(selectionKey); } } } // 处理请求 private void handleKey(SelectionKey selectionKey) throws IOException { // 接受请求 ServerSocketChannel server = null; SocketChannel client = null; String receiveText; String sendText; int count=0; // 测试此键的通道是否已准备好接受新的套接字连接。 if (selectionKey.isAcceptable()) { // 返回为之创建此键的通道。 server = (ServerSocketChannel) selectionKey.channel(); // 接受到此通道套接字的连接。 // 此方法返回的套接字通道（如果有）将处于阻塞模式。 client = server.accept(); // 配置为非阻塞 client.configureBlocking(false); // 注册到selector，等待连接 client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { // 返回为之创建此键的通道。 client = (SocketChannel) selectionKey.channel(); //将缓冲区清空以备下次读取 receivebuffer.clear(); //读取服务器发送来的数据到缓冲区中 System.out.println(System.currentTimeMillis()); count = client.read(receivebuffer); System.out.println(System.currentTimeMillis() + "~"+count); } } /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub int port = 1234; TestReadServer server = new TestReadServer(port); server.listen(); } }客户端TestReadClient.javaimport java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; 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.SocketChannel; import java.util.Iterator; import java.util.Set; public class TestReadClient { /*标识数字*/ private static int flag = 0; /*缓冲区大小*/ private static int BLOCK = 1024*1024*10; /*接受数据缓冲区*/ private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*发送数据缓冲区*/ private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); /*服务器端地址*/ private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress( "localhost", 1234); public static void main(String[] args) throws IOException { // TODO Auto-generated method stub // 打开socket通道 SocketChannel socketChannel = SocketChannel.open(); // 设置为非阻塞方式 socketChannel.configureBlocking(false); // 打开选择器 Selector selector = Selector.open(); // 注册连接服务端socket动作 socketChannel.register(selector, SelectionKey.OP_CONNECT); // 连接 socketChannel.connect(SERVER_ADDRESS); // 分配缓冲区大小内存 SetSelectionKey selectionKeys; IteratorSelectionKey iterator; SelectionKey selectionKey; SocketChannel client; String receiveText; String sendText; int count=0; while (true) { //选择一组键，其相应的通道已为 I/O 操作准备就绪。 //此方法执行处于阻塞模式的选择操作。 selector.select(); //返回此选择器的已选择键集。 selectionKeys = selector.selectedKeys(); //System.out.println(selectionKeys.size()); iterator = selectionKeys.iterator(); while (iterator.hasNext()) { selectionKey = iterator.next(); if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判断此通道上是否正在进行连接操作。 // 完成套接字通道的连接过程。 if (client.isConnectionPending()) { client.finishConnect(); System.out.println("完成连接!"); sendbuffer.clear(); BufferedInputStream br = new BufferedInputStream(new FileInputStream(new File("D:\BigData.zip"))); byte[] b = new byte[BLOCK]; br.read(b); sendbuffer.put(b); sendbuffer.flip(); System.out.println(System.currentTimeMillis()); client.write(sendbuffer); System.out.println(System.currentTimeMillis()); } client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { client = (SocketChannel) selectionKey.channel(); //将缓冲区清空以备下次读取 receivebuffer.clear(); //读取服务器发送来的数据到缓冲区中 count=client.read(receivebuffer); if(count0){ receiveText = new String( receivebuffer.array(),0,count); System.out.println("客户端接受服务器端数据--:"+receiveText); client.register(selector, SelectionKey.OP_WRITE); } } } selectionKeys.clear(); } } }例子是TestReadClient向TestReadServer发送一个本地文件。TestReadServer收到后每次打印读取到的字节数。
如何体现异步I/O？
看看TestReadClient中的：
if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判断此通道上是否正在进行连接操作。 // 完成套接字通道的连接过程。 if (client.isConnectionPending()) { client.finishConnect();如果没有client.finishConnect();这句等待完成socket连接，可能会报异常：java.nio.channels.NotYetConnectedException
异步的才不会管你有没有连接成功，都会执行下面的代码。这里需要人为的干预。
如果要证明是java的nio单独使用非阻塞I/O，真没办法！！！阻塞非阻塞要查看进程。。。
不过还有种说法，叫异步非阻塞。上面那段，是用异步方式创建连接，进程当然没有被阻塞。使用了finishConnect()这是人为将程序中止，等待连接创建完成（是模仿阻塞将当前进程阻塞掉，还是模仿非阻塞不断轮询访问，不重要了反正是程序卡住没往下执行）。
所以，创建连接的过程用异步非阻塞I/O可以解释的通。那read/write的过程呢？
根据上面例子的打印结果，可以知道这个过程是同步的，没执行完是不会执行下面的代码的。至于底下是使用阻塞I/O还是非阻塞I/O，对于应用级程序来说不重要了。
阻塞还是非阻塞，对于正常的开发（创立连接，从连接中读写数据）并没有多少的提升，操作过程都类似。
那NIO凭什么成为高性能架构的基础，比起IO，性能优越在哪里，接着猜。。。
java nio有意模仿操作系统的通道控制方式，那他的底层是不是就是直接使用操作系统的通道？
通道中的数据是以块为单位的，之前的流是以字节为单位的，同样的数据流操作外设的次数较多。代码中channel都是针对ByteBuffer对象进行read/write的，而ByteBuffer又是ByteBuffer.allocate(BLOCK);这样创建的，是一个连续的块空间。
那ByteBuffer是不是也是模拟操作系统的缓存？
缓存在io也有，如BufferedInputStream。CPU和外设的速度差很多，缓存为了提高CPU使用率，等外设将数据读入缓存后，CPU再统一操作，不用外设读一次，CPU操作一次，CPU的效率会被拉下来。。。
利用java.nio的FileChannel能够实现按行读取文件：
具体思路是：设置两个缓冲区，一大一小，大的缓冲区为每次读取的量，小的缓冲区存放每行的数据（确保大小可存放文本中最长的那行）。读取的时候判断是不是换行符13，是的话则返回一行数据，不是的话继续读取，直到读完文件。
实现方法：
FileChannel fc=raf.getChannel();
//一次读取文件，读取的字节缓存数
ByteBuffer fbb=ByteBuffer.allocate(1024*5);
fc.read(fbb);
fbb.flip();
//每行缓存的字节 根据你的实际需求
ByteBuffer bb=ByteBuffer.allocate(500);
//判断是否读完文件
public boolean hasNext() throws IOException {
if(EOF)return false;
if(fbb.position()==fbb.limit()){//判断当前位置是否到了缓冲区的限制
if(readByte()==0) return false;
}
while(true){
if(fbb.position()==fbb.limit()){
if(readByte()==0) break;
}
byte a=fbb.get();
if(a==13){
if(fbb.position()==fbb.limit()){
if(readByte()==0) break;
}
return true;
}else{
if (bb.position() bb.limit()) {
bb.put(a);
}else {
if(readByte()==0) break;
}
}
}
return true;
}
