Android NIO(Noblocking I/O非阻塞I/O)小结

参考：http://www.cnblogs.com/cpcpc/archive/2011/06/27/2123009.html

对于Android的网络通讯性能的提高，我们可以使用Java上高性能的NIO (New I/O) 技术进行处理，NIO是从JDK 1.4开始引入的，NIO的N我们可以理解为Noblocking即非阻塞的意思，相对应传统的I/O，比如Socket的accpet()、read()这些方法而言都是阻塞的。

  NIO主要使用了Channel和Selector来实现，Java的Selector类似Winsock的Select模式，是一种基于事件驱动的，整个处理方法使用了轮训的状态机，如果你过去开发过Symbian应用的话这种方式有点像活动对象，好处就是单线程更节省系统开销，NIO的好处可以很好的处理并发，对于Android网游开发来说比较关键，对于多点Socket连接而言使用NIO可以大大减少线程使用，降低了线程死锁的概率，毕竟手机游戏有UI线程，音乐线程，网络线程，管理的难度可想而知，同时I/O这种低速设备将影响游戏的体验。

  NIO作为一种中高负载的I/O模型，相对于传统的BIO (Blocking I/O)来说有了很大的提高，处理并发不用太多的线程，省去了创建销毁的时间，如果线程过多调度是问题，同时很多线程可能处于空闲状态，大大浪费了CPU时间，同时过多的线程可能是性能大幅下降，一般的解决方案中可能使用线程池来管理调度但这种方法治标不治本。使用NIO可以使并发的效率大大提高。当然NIO和JDK 7中的AIO还存在一些区别，AIO作为一种更新的当然这是对于Java而言，如果你开发过Winsock服务器，那么IOCP这样的I/O完成端口可以解决更高级的负载，当然了今天主要给大家讲解下为什么使用NIO在Android中有哪些用处。

   NIO我们分为几个类型分别描述，作为Java的特性之一，我们需要了解一些新的概念，比如ByteBuffer类，Channel，SocketChannel，ServerSocketChannel，Selector和SelectionKey。有关具体的使用，可以在Android SDK文档中看下java.nio和java.nio.channels两个包了解。

Android NIO主要分为三大类，ByteBuffer、FileChannel和SocketChannel。NIO和传统的I/O比较大的区别在于传输方式非阻塞，一种基于事件驱动的模式，将会使方法执行完后立即返回，传统I/O主要使用了流Stream的方式，而在New I/O中，使用了字节缓存ByteBuffer来承载数据。

   ByteBuffer位于java.nio包中，目前提供了Java基本类型中除Boolean外其他类型的缓冲类型，比如ByteBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer和ShortBuffer  。同时还提供了一种更特殊的映射字节缓冲类型MappedByteBuffer。在传统IO的输入输出流中，InputStream中只提供了字节型或字节数组的访问对应NIO就是ByteBuffer，但是处理传统的DataInputStream的int等类型，就是IntBuffer，但是缓冲类型并没有提供UTF这样的类型处理，所以我们仍然需要使用ByteBuffer处理字符串，但是NIO提供了一个封装的类在java.nio.charset包中，通过字符的编码CharsetEncoder和解码CharsetDecoder类来处理字符串，同时这些类可以方便转换编码比如GBK或UTF等等。

  一、ByteBuffer类

  1) 实例化

  直接使用ByteBuffer类的静态方法static ByteBuffer allocate(int capacity) 或 static ByteBuffer allocateDirect(int capacity)  这两个方法来分配内存空间，两种方法的区别主要是后者更适用于繁复分配的字节数组。而 put(ByteBuffer src) 可以从另一个ByteBuffer中构造，也可以通过wrap方法从byte[]中构造，具体参考下面的类型转化内容。

  2) 类型转化

   ByteBuffer可以很好的和字节数组byte[]转换类型，通过执行ByteBuffer类的final byte[]  array() 方法就可以将ByteBuffer转为byte[]。从byte[]来构造ByteBuffer可以使用wrap方法，目前Android或者说Java提供了两种重写方法，比如为static ByteBuffer  wrap(byte[] array)  和 static ByteBuffer  wrap(byte[] array, int start, int len)  ，第二个重载方法中第二个参数为从array这个字节数组的起初位置，第三个参数为array这个字节数组的长度。

  3) 往ByteBuffer中添加元素

  目前ByteBuffer提供了多种put重写类型来添加，比如put(byte b) 、putChar(char value) 、putFloat(float value) 等等，需要注意的是，按照Java的类型长度，一个byte占1字节，一个char类型是2字节，一个float或int是4字节，一个long则为8字节，和传统的C++有些区别。所以内部的相关位置也会发生变化，同时每种方法还提供了定位的方法比如ByteBuffer  put(int index, byte b) 

  4) 从ByteBuffer中获取元素

  同上面的添加想法，各种put被换成了get，比如byte  get()  、float  getFloat()  ，当然了还提供了一种定位的方式，比如double  getDouble(int index) 

  5) ByteBuffer中字节顺序

  对于Java来说默认使用了BIG_ENDIAN方式存储，和C正好相反的，通过

  final ByteOrder  order() 返回当前的字节顺序。

  final ByteBuffer  order(ByteOrder byteOrder)  设置字节顺序，ByteOrder类的值有两个定义，比如LITTLE_ENDIAN、BIG_ENDIAN，如果使用当前平台则为ByteOrder.nativeOrder()在Android中则为 BIG_ENDIAN，当然如果设置为order(null) 则使用LITTLE_ENDIAN。

  二、FileChannel类

   在NIO中除了Socket外，还提供了File设备的通道类，FileChannel位于java.nio.channels.FileChannel包中，在Android SDK文档中我们可以方便的找到，对于文件复制我们可以使用ByteBuffer方式作为缓冲，比如

  String infile = "/sdcard/cwj.dat";
  String outfile = "/sdcard/android123-test.dat";

    FileInputStream fin = new FileInputStream( infile );
    FileOutputStream fout = new FileOutputStream( outfile );

    FileChannel fcin = fin.getChannel();
    FileChannel fcout = fout.getChannel();

    ByteBuffer buffer = ByteBuffer.allocate( 1024 ); //分配1KB作为缓冲区

    while (true) {
    buffer.clear(); //每次使用必须置空缓冲区

      int r = fcin.read( buffer );

      if (r==-1) {
        break;
      }

   buffer.flip(); //写入前使用flip这个方法

      fcout.write( buffer );
    }

   flip和clear这两个方法是java.nio.Buffer包中，ByteBuffer的父类是从Buffer类继承而来的，提醒大家看Android SDK文档时注意Inherited Methods，而JDK的文档就比较直接了，同时复制文件使用FileChannel的transferTo(long position, long count, WritableByteChannel target) 这个方法可以快速的复制文件，无需自己管理ByteBuffer缓冲区。

http://www.jb51.net/article/64733.htm

一起来看看Android NIO有关Socket操作提供的类吧:

  一、ServerSocketChannel 服务器套接字通道在Android SDK中查找package名为  java.nio.channels.ServerSocketChannel

   在Java的NIO中，ServerSocketChannel对应的是传统IO中的ServerSocket，通过ServerSocketChannel类的socket() 方法可以获得一个传统的ServerSocket对象，同时从ServerSocket对象的getChannel() 方法，可以获得一个ServerSocketChannel()对象，这点说明NIO的ServerSocketChannel和传统IO的ServerSocket是有关联的，实例化ServerSocketChannel 只需要直接调用ServerSocketChannel 类的静态方法open()即可。

  二、 SocketChannel 套接字通道 java.nio.channels.SocketChannel   

  在Java的New I/O中，处理Socket类对应的东西，我们可以看做是SocketChannel，套接字通道关联了一个Socket类，这一点使用SocketChannel类的socket() 方法可以返回一个传统IO的Socket类。SocketChannel()对象在Server中一般通过Socket类的getChannel()方法获得。

 三、SelectionKey 选择键 java.nio.channels.SelectionKey

  在NIO中SelectionKey和Selector是最关键的地方，SelectionKey类中描述了NIO中比较重要的事件，比如OP_ACCEPT(用于服务器端)、OP_CONNECT(用于客户端)、OP_READ和OP_WRITE。

 四、Selector 选择器 java.nio.channels.Selector

  在NIO中注册各种事件的方法主要使用Selector来实现的，构造一个Selector对象，使用Selector类的静态方法open()来实例化。

  对于Android平台上我们实现一个非阻塞的服务器，过程如下:

   1. 通过Selector类的open()静态方法实例化一个Selector对象。

   2. 通过ServerSocketChannel类的open()静态方法实例化一个ServerSocketChannel对象。

   3. 显示的调用ServerSocketChannel对象的configureBlocking(false);方法，设置为非阻塞模式，Android123提示网友这一步十分重要。

   4. 使用ServerSocketChannel对象的socket()方法返回一个ServerSocket对象，使用ServerSocket对象的bind()方法绑定一个IP地址和端口号

   5. 调用ServerSocketChannel对象的register方法注册感兴趣的网络事件，很多开发者可能发现Android SDK文档中没有看到register方法，这里Android开发网给大家一个ServerSocketChannel类的继承关系  

java.lang.Object

   ↳ java.nio.channels.spi.AbstractInterruptibleChannel

     ↳ java.nio.channels.SelectableChannel

       ↳ java.nio.channels.spi.AbstractSelectableChannel

         ↳ java.nio.channels.ServerSocketChannel

   这里我们使用的register方法其实来自ServerSocketChannel的父类java.nio.channels.SelectableChannel，该方法原型为 final SelectionKey  register(Selector selector, int operations)  ，参数为我们执行第1步时的selector对象，参数二为需要注册的事件，作为服务器，我们当然是接受客户端发来的请求，所以这里使用SelectionKey.OP_ACCEPT了。

  6. 通过Selector对象的select() 方法判断是否有我们感兴趣的事件发生，这里就是OP_ACCEPT事件了。我们通过一个死循环获取Selector对象执行select()方法的值，SDK中的原始描述为the number of channels that are ready for operation.，就是到底有多少个通道返回。

  7. 如果 Selector对象的select()方法返回的结果数大于0，则通过selector对象的selectedKeys()方法获取一个SelectionKey类型的Set集合，我们使用Java的迭代器Iterator类来遍历这个Set集合，注意判断SelectionKey对象，

  8. 为了表示我们处理了SelectionKey对象，需要先移除这个SelectionKey对象从Set集合中。这句很关键Android 123提醒网友注意这个地方。

  9. 接下来判断SelectionKey对象的事件，因为我们注册的感兴趣的是SelectionKey.OP_ACCEPT事件，我们使用SelectionKey对象的isAcceptable()方法判断，如果是我们创建一个临时SocketChannel对象类似上面的方法继续处理，不过这时这个SocketChannel对象主要处理读写操作，我们注册SelectionKey.OP_READ和SelectionKey.OP_WRITE分配ByteBuffer缓冲区，进行网络数据传输。

 ＝＝＝＝＝＝＝＝对于开发安卓应用，还没有具体场景用NIO。＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

但是，在官方给出的OpenGL教程中却用到了，所以，记录一下：

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.edaixi.opengl;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;

import javax.microedition.khronos.opengles.GL10;

/**
 * A two-dimensional square for use as a drawn object in OpenGL ES 1.0/1.1.
 */
public class Square {

    private final FloatBuffer vertexBuffer;
    private final ShortBuffer drawListBuffer;

    // number of coordinates per vertex in this array
    static final int COORDS_PER_VERTEX = 3;
    static float squareCoords[] = {
            -0.5f,  0.5f, 0.0f,   // top left
            -0.5f, -0.5f, 0.0f,   // bottom left
             0.5f, -0.5f, 0.0f,   // bottom right
             0.5f,  0.5f, 0.0f }; // top right

    private final short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices

    float color[] = { 0.2f, 0.709803922f, 0.898039216f, 1.0f };

    /**
     * Sets up the drawing object data for use in an OpenGL ES context.
     */
    public Square() {
        // initialize vertex byte buffer for shape coordinates
        ByteBuffer bb = ByteBuffer.allocateDirect(
        // (# of coordinate values * 4 bytes per float)
                squareCoords.length * 4);
        bb.order(ByteOrder.nativeOrder());
        vertexBuffer = bb.asFloatBuffer();
        vertexBuffer.put(squareCoords);
        vertexBuffer.position(0);

        // initialize byte buffer for the draw list
        ByteBuffer dlb = ByteBuffer.allocateDirect(
                // (# of coordinate values * 2 bytes per short)
                drawOrder.length * 2);
        dlb.order(ByteOrder.nativeOrder());
        drawListBuffer = dlb.asShortBuffer();
        drawListBuffer.put(drawOrder);
        drawListBuffer.position(0);
    }

    /**
     * Encapsulates the OpenGL ES instructions for drawing this shape.
     *
     * @param gl - The OpenGL ES context in which to draw this shape.
     */
    public void draw(GL10 gl) {
        // Since this shape uses vertex arrays, enable them
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

        // draw the shape
        gl.glColor4f(       // set color
                color[0], color[1],
                color[2], color[3]);
        gl.glVertexPointer( // point to vertex data:
                COORDS_PER_VERTEX,
                GL10.GL_FLOAT, 0, vertexBuffer);
        gl.glDrawElements(  // draw shape:
                GL10.GL_TRIANGLES,
                drawOrder.length, GL10.GL_UNSIGNED_SHORT,
                drawListBuffer);

        // Disable vertex array drawing to avoid
        // conflicts with shapes that don't use it
        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    }
}