javaNIO编程

Wesley13
• 阅读 676

Unblocking IO(New IO): 同步非阻塞的编程方式

NIO 本身是基于事件驱动思想来完成的,其主要想解决的是 BIO 的大并发问题,NIO 基 于 Reactor,当 socket 有流可读或可写入 socket 时,操作系统会相应的通知引用程序进行处 理,应用再将流读取到缓冲区或写入操作系统。也就是说,这个时候,已经不是一个连接就 要对应一个处理线程了,而是有效的请求,对应一个线程,当连接没有数据时,是没有工作 线程来处理的。 

NIO 的最重要的地方是当一个连接创建后,不需要对应一个线程,这个连接会被注册到 多路复用器上面,所以所有的连接只需要一个线程就可以搞定,当这个线程中的多路复用器 进行轮询的时候,发现连接上有请求的话,才开启一个线程进行处理,也就是一个请求一个 线程模式

在 NIO 的处理方式中,当一个请求来的话,开启线程进行处理,可能会等待后端应用的 资源(JDBC 连接等),其实这个线程就被阻塞了,当并发上来的话,还是会有 BIO 一样的问题。

javaNIO编程

 同步非阻塞,服务器实现模式为一个请求一个通道,即客户端发送的连接请求都会注册 到多路复用器上,多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。 NIO 方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,并发局 限于应用中,编程复杂,JDK1.4 开始支持。 

Buffer:ByteBuffer,CharBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatBuffer,DoubleBuffer

Channel:SocketChannel,ServerSocketChannel 。
Selector:Selector,AbstractSelector SelectionKey:OP_READ,OP_WRITE,OP_CONNECT,OP_ACCEPT

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

public class NIOClient {
    public static void main(String[] args) {
        // 远程地址创建
        InetSocketAddress remote =new InetSocketAddress("localhost",  9999);
        SocketChannel channel = null;
        
        // 定义缓存
        ByteBuffer buffer =ByteBuffer.allocate(1024);
        
        try {
            // 开启通道
            channel=SocketChannel.open();
            // 连接远程服务器。
            channel.connect(remote);
            Scanner reader = new Scanner(System.in);
            while(true){
                System.out.print("put message for send to server > ");
                String line = reader.nextLine();
                if(line.equals("exit")){
                    break;
                }
                // 将控制台输入的数据写入到缓存。
                 buffer.put(line.getBytes("UTF-8"));
                // 重置缓存游标
                 buffer.flip();
                // 将数据发送给服务器
                channel.write(buffer);
                // 清空缓存数据。
                buffer.clear();
                
                // 读取服务器返回的数据
                int readLength=channel.read(buffer);
                if(readLength==-1) break;
                // 重置缓存游标
                buffer.flip();
                byte[] datas=new byte[buffer.remaining()];
                // 读取数据到字节数组。
                buffer.get(datas);
                System.out.println("from server : " + new String(datas, "UTF-8"));
                // 清空缓存。
                buffer.clear();
            }
        } catch (IOException  e) {
            e.printStackTrace();
        }finally{
            if(null != channel){
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.CancelledKeyException;
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.Scanner;

public class NioService implements Runnable {
    
    // 多路复用器, 选择器。 用于注册通道的。
    private Selector selector;
    // 定义了两个缓存。分别用于读和写。 初始化空间大小单位为字节。
    private ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    private ByteBuffer writeBuffer = ByteBuffer.allocate(1024);

    public static void main(String[] args) {
        new Thread(new NioService(9999)).start();
    }
    
    public NioService(int port){
        init(port);
    }
    
    private void init(int port){
        try {
            System.out.println("server starting at port " + port + " ...");
            // 开启多路复用器
            this.selector=Selector.open();
            // 开启服务通道
            ServerSocketChannel serverChannel =ServerSocketChannel.open();
            // 非阻塞, 如果传递参数true,为阻塞模式。
            serverChannel.configureBlocking(false);
            // 绑定端口
            serverChannel.bind(new InetSocketAddress(port));
            
            // 注册,并标记当前服务通道状态
            
            /*
             * register(Selector, int)
             * int - 状态编码
             *  OP_ACCEPT : 连接成功的标记位。
             *  OP_READ : 可以读取数据的标记
             *  OP_WRITE : 可以写入数据的标记
             *  OP_CONNECT : 连接建立后的标记
             */
            serverChannel.register(this.selector, SelectionKey.OP_ACCEPT);
            System.out.println("server started.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void run(){
        while(true){
            try {
                // 阻塞方法,当至少一个通道被选中,此方法返回。
                // 通道是否选择,由注册到多路复用器中的通道标记决定。
                this.selector.select();
                // 返回以选中的通道标记集合, 集合中保存的是通道的标记。相当于是通道的ID。
                Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
                while(keys.hasNext()){
                    SelectionKey key = keys.next();
                    // 将本次要处理的通道从集合中删除,下次循环根据新的通道列表再次执行必要的业务逻辑
                    keys.remove();
                    // 通道是否有效
                    if(key.isValid()){
                        // 阻塞状态
                        try{
                            if(key.isAcceptable()){
                                accept(key);
                            }
                        }catch(CancelledKeyException cke){
                            // 断开连接。 出现异常。
                            key.cancel();
                        }
                        // 可读状态
                        try{
                            if(key.isReadable()){
                                read(key);
                            }
                        }catch(CancelledKeyException cke){
                            key.cancel();
                        }
                        // 可写状态
                        try{
                            if(key.isWritable()){
                                write(key);
                            }
                        }catch(CancelledKeyException cke){
                            key.cancel();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
    }

    private void write(SelectionKey key){
        this.writeBuffer.clear();
        SocketChannel  channel =(SocketChannel) key.channel();
        Scanner reader=new Scanner(System.in);
        try {
            System.out.print("put message for send to client > ");
            String line=reader.nextLine();
            // 将控制台输入的字符串写入Buffer中。 写入的数据是一个字节数组。
            writeBuffer.put(line.getBytes("UTF-8"));
            writeBuffer.flip();
            channel.write(writeBuffer);
            
            channel.register(this.selector, SelectionKey.OP_READ);
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

    private void read(SelectionKey key){
        try {
            // 清空读缓存。
            this.readBuffer.clear();
            //获取通道
            SocketChannel  channel =(SocketChannel)key.channel();
            // 将通道中的数据读取到缓存中。通道中的数据,就是客户端发送给服务器的数据。
            int readLength =channel.read(readBuffer);
            // 检查客户端是否写入数据。
            if(readLength==-1){
                // 关闭通道
                key.channel().close();
                // 关闭连接
                key.cancel();
                return;
            }
            /*
             * flip, NIO中最复杂的操作就是Buffer的控制。
             * Buffer中有一个游标。游标信息在操作后不会归零,如果直接访问Buffer的话,数据有不一致的可能。
             * flip是重置游标的方法。NIO编程中,flip方法是常用方法。
             */
            this.readBuffer.flip();
            // 字节数组,保存具体数据的。 Buffer.remaining() -> 是获取Buffer中有效数据长度的方法。
            byte[] datas=new byte[readBuffer.remaining()];
            // 是将Buffer中的有效数据保存到字节数组中。
            readBuffer.get(datas);
            System.out.println("from " + channel.getRemoteAddress() + " client : " + new String(datas, "UTF-8"));
            
            // 注册通道, 标记为写操作。
            channel.register(this.selector, SelectionKey.OP_WRITE);
        } catch (IOException  e) {
            e.printStackTrace();
            try {
                key.channel().close();
                key.cancel();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
 
    private void accept(SelectionKey key){
        try {
            // 此通道为init方法中注册到Selector上的ServerSocketChannel
            ServerSocketChannel serverChannel =(ServerSocketChannel)key.channel();
            // 阻塞方法,当客户端发起请求后返回。 此通道和客户端一一对应。
            SocketChannel channel = serverChannel.accept();
            channel.configureBlocking(false);
            // 设置对应客户端的通道标记状态,此通道为读取数据使用的。
            channel.register(this.selector, SelectionKey.OP_READ);    
        } catch (IOException  e) {
            e.printStackTrace();
        }
    }

}

/**
 * 
 * Buffer的应用固定逻辑
 * 写操作顺序
 * 1. clear()
 * 2. put() -> 写操作
 * 3. flip() -> 重置游标
 * 4. SocketChannel.write(buffer); -> 将缓存数据发送到网络的另一端
 * 5. clear()
 * 
 * 读操作顺序
 * 1. clear()
 * 2. SocketChannel.read(buffer); -> 从网络中读取数据
 * 3. buffer.flip() -> 重置游标
 * 4. buffer.get() -> 读取数据
 * 5. buffer.clear()
 *
 */
public class TestBuffer {
    public static void main(String[] args) throws Exception {
        
        ByteBuffer buffer = ByteBuffer.allocate(8);
        
        byte[] temp = new byte[]{3,2,1};
        
        // 写入数据之前 : java.nio.HeapByteBuffer[pos=0 lim=8 cap=8]
        // pos - 游标位置, lim - 限制数量, cap - 最大容量
        System.out.println("写入数据之前 : " + buffer);
        
        // 写入字节数组到缓存
        buffer.put(temp);
        
        // 写入数据之后 : java.nio.HeapByteBuffer[pos=3 lim=8 cap=8]
        // 游标为3, 限制为8, 容量为8
        System.out.println("写入数据之后 : " + buffer);
        
        // 重置游标 , lim = pos ;  pos = 0;
        buffer.flip();
        
        // 重置游标之后 : java.nio.HeapByteBuffer[pos=0 lim=3 cap=8]
        // 游标为0, 限制为3, cap为8
        System.out.println("重置游标之后 : " + buffer);

        // 清空Buffer, pos = 0; lim = cap;
        // buffer.clear();
        
        // get() -> 获取当前游标指向的位置的数据。
        // System.out.println(buffer.get());
        
        /*for(int i = 0; i < buffer.remaining(); i++){
            // get(int index) -> 获取指定位置的数据。
            int data = buffer.get(i);
            System.out.println(i + " - " + data);
        }*/
    }
}
点赞
收藏
评论区
推荐文章
blmius blmius
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
皕杰报表之UUID
​在我们用皕杰报表工具设计填报报表时,如何在新增行里自动增加id呢?能新增整数排序id吗?目前可以在新增行里自动增加id,但只能用uuid函数增加UUID编码,不能新增整数排序id。uuid函数说明:获取一个UUID,可以在填报表中用来创建数据ID语法:uuid()或uuid(sep)参数说明:sep布尔值,生成的uuid中是否包含分隔符'',缺省为
待兔 待兔
3个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
Jacquelyn38 Jacquelyn38
3年前
2020年前端实用代码段,为你的工作保驾护航
有空的时候,自己总结了几个代码段,在开发中也经常使用,谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
Wesley13 Wesley13
3年前
Java NIO
简介引入NIO的原因1.因为BIO都是阻塞的IO,为了使Java能支持非阻塞I/O,JDK引入了NIO,可以将NIO理解成是NonblockI/O.(也有书说是newIO)2.BIO编程中,每当有一个新的客户端请求过来时,服务器端必须创建一个新的线程处理新接入的客户端链路,一个线程只能处理一个客户端连接,在并发量
Wesley13 Wesley13
3年前
NIO 非阻塞IO
NIO与IO的区别NIO特点:非阻塞,面向缓冲区IO特点:阻塞式,面向流阻塞与非阻塞javaio是阻塞式的,当一个线程调用read或者write方法后开始阻塞,直到读取到数据或者写入数据完成,该线程一直处于阻塞状态不能做其他事情。javanio通过选择器实现非阻塞式IO,通过一个专门的选
Wesley13 Wesley13
3年前
00:Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork),斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。Java是简单易学,完全面向对象,安全可靠,与平台无关的编程语言。
Stella981 Stella981
3年前
Django中Admin中的一些参数配置
设置在列表中显示的字段,id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
Wesley13 Wesley13
3年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
Python进阶者 Python进阶者
9个月前
Excel中这日期老是出来00:00:00,怎么用Pandas把这个去除
大家好,我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下:这日期老是出来00:00:00,怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下:pd.toexcel之前把这