1、BIO带来的挑战

  BIO即阻塞IO,不管是磁盘IO,还是网络IO,数据在写入OutputStream或者从InputStream读取时都有可能发生阻塞,一旦有阻塞,当前线程将会被挂起,即线程进入非可执行状态,在这个状态下,CPU不会给线程分配时间片,线程将会失去CPU的使用权,即线程暂停运行,这在当前的大规模访问量和有性能要求的情况下是不能被接受的。虽然当前的网络I/O有一些解决办法,如一个客户端一个处理线程,出现阻塞时只是一个线程阻塞而不会影响其他线程工作,还有为了减少系统线程的开销  ,采用线程池的办法来减少线程创建和回收的成本。如下例子:

Socket的Server端

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
public class Server {
  
   public static void main(String args[]) throws IOException {
      //为了简单起见,所有的异常信息都往外抛
      int port = 8899;
      //定义一个ServerSocket监听在端口8899上
      ServerSocket server = new ServerSocket(port);
      while (true) {
         //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
         Socket socket = server.accept();
         //每接收到一个Socket就建立一个新的线程来处理它(这里可以使用pool线程池)
         new Thread(new Task(socket)).start();
      }
   }
    
   /**
    * 用来处理Socket请求的
    */
   static class Task implements Runnable {
      private Socket socket;
      public Task(Socket socket) {
         this.socket = socket;
      }
      public void run() {
         try {
            handleSocket();
         catch (Exception e) {
            e.printStackTrace();
         }
      }
 
      /**
       * 跟客户端Socket进行通信
      * @throws Exception
       */
      private void handleSocket() throws Exception {
         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK"));
         StringBuilder sb = new StringBuilder();
         String temp;
         int index;
         while ((temp=br.readLine()) != null) {
            System.out.println(temp);
            if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
             sb.append(temp.substring(0, index));
                break;
            }
            sb.append(temp);
         }
         System.out.println("客户端: " + sb);
         //读完后写一句
       Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
         writer.write("你好,客户端。");
         writer.write("eof\n");
         writer.flush();
         writer.close();
         br.close();
         socket.close();
      }
   }
}

client客户端

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
public class Client {
  
   public static void main(String args[]) throws Exception {
      //为了简单起见,所有的异常都直接往外抛
     String host = "127.0.0.1";  //要连接的服务端IP地址
     int port = 8899;   //要连接的服务端对应的监听端口
     //与服务端建立连接
     Socket client = new Socket(host, port);
      //建立连接后就可以往服务端写数据了
     Writer writer = new OutputStreamWriter(client.getOutputStream(), "GBK");
      writer.write("你好,服务端。");
      writer.write("eof\n");
      writer.flush();
      //写完以后进行读操作
     BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8"));
      //设置超时间为10秒
     client.setSoTimeout(10*1000);
      StringBuffer sb = new StringBuffer();
      String temp;
      int index;
      try {
         while ((temp=br.readLine()) != null) {
            if ((index = temp.indexOf("eof")) != -1) {
                sb.append(temp.substring(0, index));
                break;
            }
            sb.append(temp);
         }
      catch (SocketTimeoutException e) {
         System.out.println("数据读取超时。");
      }
      System.out.println("服务端: " + sb);
      writer.close();
      br.close();
      client.close();
   }
}

  在以上代码中,你会发现在读取写入的流中会有”eof”的结束标记符,在服务端同时读写时,读取客户端发送的数据完毕后,while循环没有跳出来,服务端也将无法向客户端返回数据,所以在while的判断中加上一个条件,当遇到自定义的结束符时,将跳出循环,继续执行下面代码。

  但是有一些使用场景下仍然是无法解决的,如当前一些需要大量HTTP长连接的情况;这里说一下什么是长连接: HTTP1.1规定了默认保持长连(HTTP persistent connection ,也有翻译为持久连接),数据传输完成了保持TCP连接不断开(不发RST包(RST包用于强制关闭TCP链接)、不四次握手),等待在同域名下继续用这个通道(Channel)传输数据;相反的就是短连接。像淘宝现在使用的Web旺旺,服务端需要同时保持几百万的HTTP连接,但并不是每时每刻这些 连接都需要传输数据,这种情况下不可能同时创建这么多线程来保持连接。即使线程的数量不是问题,仍然有一些问题是无法避免的,比如我们想给某些客户端更高的服务优先级,很难通过设计线程的优先级来完成。另外一种情况是,每个客户端的请求在服务端可能需要访问一些竞争资源,这些客户端在不同线程中,因此需要同步,要实现这种同步操作远比用单线程复杂得多。以上这些情况都说明,我们需要另外一种新的I/O操作方式。

2、NIO的工作机制

  我们先看一下NIO相关类图

  图中有 两个关键类:Channel和selector,他们是NIO的两个核心概念。我们有城市交通工具来比喻NIO的工作方式,这里的Channel哟啊比Socket更加具体,它可以比作某种具体的交通工具,如汽车或高铁,而Selector可以比作一个车站的车辆运行调度系统,它将负责监控每辆车的当前运行状态,是已经出站,还是在路上等。也就是它可以轮询每个Channel状态。这里还有一个buffer类 ,它也比Stream更加具体,我们可以将它比作车上的车位。Channel是汽车的话Buffer就是汽车上的座位,它始终是一个具体的概念,与Stream不同,Stream只能代表一个座位 ,至于是什么座位有你自己去想象,也就是你在上车之前并不知道这个车上是否还有没有座位,也不知道上的额是什么车 ,因为你并不能选择。而这些信息都已经被封装在了运输工具(Socket)里面(Socket里面自带了一个IO Stream流),对你是透明的(你是看不见的,你并不知道它的大小,工作方式)。

  NIO引入了Channel、Buffer和Selector就是想把这些信息具体化,让程序员能够有机会控制它们。例如,当我呢吧调用write()往SendQ中写数据时,当一次写的数据超过SendQ长度时需要按照SendQ的长度进行分割,这个过程中需要将用户空间数据和内核地址空间进行切换,而这个切换不是你可以控制的,但在Buffer中我们可以控制Buffer的容量、是否扩容以及如何扩容。

  这里不得不说一下SendQ和RecvQ的两个参数了

  RecvQ:表示网络接收队列。表示收到的数据已经在本地接收缓冲,但是还有部分没有被进程取走,就缓冲在队列,知道进程有空闲取走为止。一般缓冲在队列的时间不会很长。如果接收队列RecvQ一直处在阻塞状态,可能遭受了拒绝服务denial-of-service攻击。

  SenQ:表示网络发送队列。对方没有收到的数据或者没有Ack(正确应答信号)的,IO流还是在本地缓冲区。如果发送队列SendQ不能很快清零,可能是有应用向外发送数据包过快,或者对方接收数据包不够快。

这两个值通常应该为0的,如果不为0可能是有问题的。Packets包在两个队列里都不应该有堆积状态。可接受短暂的非零情况。

  理解了这些概念后,我们看一下实际上它们是如何工作的,下面是一段典型的NIO代码:

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
public void selector() throws IOException{
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Selector selector = Selector.open();
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);//非阻塞
        ssc.socket().bind(new InetSocketAddress(8080));
        ssc.register(selector, SelectionKey.OP_ACCEPT);//注册监听事件
        while(true){
            Set selectedkeys = selector.selectedKeys();//取得所有key的集合
            Iterator it = selectedkeys.iterator();//set集合迭代出key
            while(it.hasNext()){//判断it的是否还有下一个,没有返回false
                SelectionKey key = (SelectionKey) it.next();
                if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
                    ServerSocketChannel serverChanel = (ServerSocketChannel)key.channel();
                    SocketChannel sc = serverChanel.accept();
                    sc.configureBlocking( false );
                    SelectionKey newKey = sc.register( selector,SelectionKey.OP_READ);
                    it.remove();
                }else if((key.readyOps() & SelectionKey.OP_READ)== SelectionKey.OP_READ){
                    SocketChannel sc = (SocketChannel)key.channel(); //通过学号知道是谁问的问题
                    int bytesEchoed = 0;
                    while(true){
                        buffer.clear();
                        int n = sc.read(buffer);
                        if(n<=0){
                            break;
                        }
                        buffer.flip();//反转缓冲区,这时操作系统就可以正确的读取字节发送出去
                    }
                    it.remove();
                }
            }
        }
    }

以上代码,就算看着JDK API可能理解起来比较吃力,所以通过某些情景来理解,印象可能会更加深刻。

在用NIO通讯的过程中我用以下情景模拟:

1. 学校(ServerSocketChannel)

2. 学校教务处(Selector)

3. 老师 (ServerSocket )

4. 学生 (SocketChannel)

5. 员工号/学生号(SelectionKey)

学校:相当于我们的网络应用程序,一旦学校启动,学校就不停止,不断运行,直到学期结束;

要启动学校就要:

1
2
ServerSocketChannel ssc= ServerSocketChannel.open();//新建NIO通道
ssc.configureBlocking( false );//使通道为非阻塞

老师: 相当于服务端的Socket,一个老师对应多个学生,多个学生向老师请教,老师会一一做出回答。而学校要正常运营当然当不了老师,所以在开学之前,必须先聘请专业的老师来任教

1
2
3
ServerSocket ss = ssc.socket();//创建基于NIO通道的socket连接
//新建socket通道的端口
ss.bind(new InetSocketAddress("127.0.0.1",SERVERPORT));

学校教务处: 老师都有了,但是需要有部门对老师和学生做统一的管理, 如果你去一个学校找一个人,实在是找不到,你可以告诉教务处,那个人是学生还是老师,是老师的话员工编号老师姓名的多少,是学生的话学号和姓名是多少,教务处就会找到告诉你他在哪里。

1
2
//将NIO通道选绑定到择器,当然绑定后分配的主键为skey
SelectionKey skey = ssc.register( selector, SelectionKey.OP_ACCEPT );

ssc注册了选择器后,其下的老师ServerSocket就也入了员工册了。所以老师的编号就是skey

学生: 学校、老师、教务处都有了,现在就可以招生了!

如果有学生来报名:

1
2
3
4
5
6
7
8
9
10
while(true){//除非学期结束,否则一直等待学生
int num = selector.select();//获取通道内是否有选择器的关心事件, 意思是有多少学生报告(注:select()方法:选择一组键,其相应的通道以为I/O操作准备就绪。返回值可能为0)
if(num<1){continue; } //当select()方法返回值>1,说明I/O操作还没准备就绪,将阻塞。小于1,往下继续执行。
Set selectedKeys = selector.selectedKeys();//获取通道内关心事件的集合 ,这里的集合就是老师和学生的编号集合,如果key是学生的,那就是老学生来问问题,如果key是老师的,那就是招生办的老师带着一个新生来注册
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {//遍历每个key (学生key和老师key)
.......
}
.....
}

既然有学生来报告,那有两种可能,一种是招生老师带着新生来注册的,一种是老生来问问题的。

上面的while (it.hasNext()) 体可以这样写:

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
while (it.hasNext()) {//遍历每个事件
try{
SelectionKey key = (SelectionKey)it.next(); //先得到这个学生的编号key
//判断是新生报道还是老生问问题
if ((key.readyOps() & SelectionKey.OP_ACCEPT)
== SelectionKey.OP_ACCEPT) {
//这是招生老师的Key说明是新生注册,先找到招生老师,再由招生老师找到新生,就可以给新生注册学号了
ServerSocketChannel serverChanel = (ServerSocketChannel)key.channel(); //通过key把学校和老师找到了
//从serverSocketChannel中创建出与客户端的连接socketChannel 有了老师才有学生,不可能我教计算机的,来一个想学李小龙的都让他报名
SocketChannel sc = serverChanel.accept(); //学生报名成功
sc.configureBlocking( false );
// 把新连接注册到选择器,新生被接收后给注册个新学号
SelectionKey newKey = sc.register( selector,
SelectionKey.OP_READ ); //注册学号成功,并分配学生的权限
it.remove(); //新生注册任务完成了,呵呵
System.out.println( "Got connection from "+sc );
}else
//读客户端数据的事件,此时有客户端发数据过来,客户端事件 这是老学生来问问题了。
if((key.readyOps() & SelectionKey.OP_READ)== SelectionKey.OP_READ){
// 读取数据 ,接受学生的问题
SocketChannel sc = (SocketChannel)key.channel(); //通过学号知道是谁问的问题
 
//下面接受问题
int bytesEchoed = 0;
while((bytesEchoed = sc.read(buffer))> 0){
System.out.println("bytesEchoed:"+bytesEchoed);
}
echoBuffer.flip();
System.out.println("limet:"+echoBuffer.limit());
byte [] content = new byte[echoBuffer.limit()];
echoBuffer.get(content);
String result=new String(content);
doPost(result,sc); //相应老师会去做回答的,细节自己去写吧
echoBuffer.clear();
it.remove(); //任务完成,记得上面也是一样,要remove掉,否则下一次又来一次任务,就死循环了
}
}catch(Exception e){}
}
}

补充:

ssc.register( selector, SelectionKey.OP_ACCEPT );

这个方法是把ssc注册绑定到选择器selector 这样下次你想找ssc或者判断一个对象是不是ssc就可以通过selector来查找,查找是通过判断ssc的key得到的。

至于第二个参数SelectionKey.OP_ACCEPT 你可以理解成ssc的key类型或者操作权限

如果 ssc是学校老师,那么绑定成功后 老师就拥有了OP_ACCEPT的权限或者说他的key类型是SelectionKey.OP_ACCEPT

Accept是接受的意思,这是不是很像socket编程里的 accept()方法呢? 是的,没错,我们正是通过这个参数给了老师招生和带学生来注册的权限。

而学生呢?

他拥有的权限为SelectionKey.OP_READ 表示有收发读取消息的权限,即问问题的权限,因此他不能帮别的学生注册。

所以你回到上面仔细看看while结构体里面做了判断如下:

if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {...} 很明显,拥有Accept权限的人只可能是老师,那老师有什么事会找教务处? 那肯定就是他是招生办的,招到一个学生来报名来注册了。

然后,马上给这个新连上来的客户端分配了一个key

SelectionKey newKey = sc.register( selector, SelectionKey.OP_READ ); 看,这里只给他OP_READ,而不是Accept哦

另一个if

else if((key.readyOps() & SelectionKey.OP_READ)== SelectionKey.OP_READ){

//很明显,这是这学生,因为所有带OP_READ的人都是前面由招生办老师带过来注册过的。

    总结一下:调用Selector的静态工厂创建一个选择器.open();创建一个服务端的Channel,ServerSocketChannel.open();并把这个通信信道注册到选择器上ssc.register(selector, SelectionKey.OP_ACCEPT);,把这个通信信道设置为非阻塞模式。然后就可以调用Selector的selectedKeys()方法来检查已经注册在这个选择器上的所有通信信道是否有需要的事件发生,如果有某个事件发生,将会返回所有的SelectedKey,通过这个对象Channel()方法就可以取得这个通信信道对象,从而可以读取通信的数据,而这里读取的数据是Buffer,这个Buffer是我们可以控制的缓冲器。

  在上面这段程序中,将Server端的监听连接请求的事件和处理请求的事件放在一个线程中,但是在事件应用中,我们通常会把它们放在两个线程中:一个线程专门负责监听客户端的连接请求,而且是以阻塞方式执行的;另外一个线程专门负责处理请求,这个专门处理请求的线程才会真正采用NIO的方式,像web服务器Tomcat和Jetty都使用这个处理方式。

下图描述了基于NIO的Socket请求的处理过程。

  其中的Selector可以同时监听一组通信信道Channel上的I/O状态,前提是这个Selector已经注册到这些信道中。选择器Selector可以调用select()方法检查已经注册的通信信道是哪个的I/O是否已经准备好,如果没有至少一组信道I/O状态有改变,那么select()方法会阻塞等待或在超时时间后返回0.如果有多个信道有数据,那么将会把这些数据分配到对应的数据Buffer中。所以关键的地方是,有一个线程来处理所有连接的数据交互,每个连接的数据交互都不是阻塞方式,所以可以同时处理大量的连接请求。

NIO-新的io操作方式的更多相关文章

  1. NIO与普通IO文件读写性能对比

    最近在熟悉java的nio功能.nio采用了缓冲区的方式进行文件的读写,这一点更接近于OS执行I/O的方式.写了个新旧I/O复制文件的代码,练练手,顺便验证一下两者读写性能的对比,nio是否真的比普通 ...

  2. 【NIO】之IO和NIO的区别

    在Java1.4之前的版本,Java对I/O的支持并不完善,开发人员在开发高性能I/O程序的时候,会面临以下几个问题: 1.没有数据缓存区,I/O性能存在问题 2.没有C/C++通道的概念,输入和输出 ...

  3. NIO 之阻塞IO和非阻塞IO(转载)

    阻塞模式 IO 我们已经介绍过使用 Java NIO 包组成一个简单的客户端-服务端网络通讯所需要的 ServerSocketChannel.SocketChannel 和 Buffer,我们这里整合 ...

  4. 少啰嗦!一分钟带你读懂Java的NIO和经典IO的区别

    1.引言 很多初涉网络编程的程序员,在研究Java NIO(即异步IO)和经典IO(也就是常说的阻塞式IO)的API时,很快就会发现一个问题:我什么时候应该使用经典IO,什么时候应该使用NIO? 在本 ...

  5. java非阻塞NIO和阻塞IO

    1         非阻塞NIO和阻塞IO 1.1           定义 阻塞IO:线程被阻塞,去处理一个读取和写入,中间如果有等待时间,则线程被占用,也不能处理其他任务: 非阻塞IO(new I ...

  6. NIO之阻塞IO与非阻塞IO(包含Selector使用)

    阻塞IO 传统的 IO 流都是阻塞式的. 也就是说,当一个线程调用 read() 或 write()时,该线程被阻塞,直到有一些数据被读取或写入,该线程在此期间不能执行其他任务. 因此,在完成网络通信 ...

  7. java学习-NIO(五)NIO学习总结以及NIO新特性介绍

    我们知道是NIO是在2002年引入到J2SE 1.4里的,很多Java开发者比如我还是不知道怎么充分利用NIO,更少的人知道在Java SE 7里引入了更新的输入/输出 API(NIO.2).但是对于 ...

  8. NIO与传统IO的区别

    传统的socket IO中,需要为每个连接创建一个线程,当并发的连接数量非常巨大时,线程所占用的栈内存和CPU线程切换的开销将非常巨大.使用NIO,不再需要为每个线程创建单独的线程,可以用一个含有限数 ...

  9. IO通信模型(二)同步非阻塞模式NIO(NonBlocking IO)

    同步非阻塞模式(NonBlocking IO) 在非阻塞模式中,发出Socket的accept()和read()操作时,如果内核中的数据还没有准备好,那么它并不会阻塞用户进程,而是立刻返回一个信息.也 ...

随机推荐

  1. js中数组去重

    编写函数norepeat(arr) 将数组的重复元素去掉,并返回新的数组 [注]正序去重,会漏掉一些元素. [注]去重倒序. var arr = [10, 20, 30, 40, 30, 20, 20 ...

  2. Thread类中的join方法

    package charpter06; //类实现接口public class Processor implements Runnable { // 重写接口方法 @Override public v ...

  3. python asyncio学习截图

    感觉对python越来越通了. 感觉不错, 截图

  4. .NET中JSON序列化(数据集转JSON)

    Json序列化和反序列化指的是:对象序列化为JSON,并可用于从 JSON 反序列化对象 在.net 3.5中已支持JSON,引用命名空间: using System.Web.Script.Seria ...

  5. Nordic Collegiate Programming Contest NCPC 2017-Problem D-Distinctive Character

    题目大意:给你n(n<=1e5)个二进制串 (每个串位数不超过20),定义两个串的相似度为对应 位置上相同的个数. 让你构造一个二进制串,使这个串与所给的这些串的相似度的最小值最大. 思路:刚开 ...

  6. R从3.4升级到3.5

    这里介绍的就是R的一个包:installr. installr {installr} R Documentation Installing software from R Description Gi ...

  7. U盘装机教程

    http://winpe.uqidong.asia/upzxpxt/upzxpxt.html

  8. android和java以太坊开发区块链应用使用web3j类库

    如何使用web3j为Java应用或Android App增加以太坊区块链支持,教程内容即涉及以太坊中的核心概念,例如账户管理包括账户的创建.钱包创建.交易转账,交易与状态.智能合约开发与交互.过滤器和 ...

  9. JVM GC-----4、finalize()方法

    finalize()方法是Object类中定义的protect方法.每一个类都可以重写该方法,给出自己的实现.当类在被回收期间,这个方法就可能会被调用到. 为什么说可能?这是由于finalize()的 ...

  10. DP-hdu1176

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1176 这道题与动态规划中的数塔问题十分类似,因此如果对于数塔问题还不太明白的,可以先参考一下博客: 数 ...