scatter和gather用于描述从Channel中读取或者写入到Channel的操作

分散（scatter）从Channel中读取是指在读操作时将读取的数据写入多个buffer中。

聚集（gather）写入Channel是指在写操作时将多个buffer的数据写入同一个Channel。

scatter和gather经常用于需要将传输的数据分开处理的场合，例如传输一个由消息头和消息体组成的消息，你可能会将消息体和消息头分散到不同的buffer中，这样你可以方便的处理消息头和消息体。

Scattering Reads

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);

ByteBuffer[] bufferArray = { hearder, body};

channel.read(bufferArray);

read()方法按照buffer在数组中的顺序将从channel中读取的数据写入到buffer，当一个buffer被写满后，channel紧接着向另一个buffer中写。

Scattering Reads在移动到下一个buffer前，必须填满当前的buffer，这也意味着它不适用于动态消息（消息大小不固定）。换句话说，如果存在消息头和消息体，消息头必须完成填充，Scattering Reads才能正常工作。

Gathering Writes

Gathering Writes是指数据从多个buffer写入到同一个channel

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);

//write data into buffers

ByteBuffer[] bufferArray = { header, body };

channel.write(bufferArray);

write()方法会按照buffer在数组中的顺序，将数据写入到channel，注意只有position和limit之间的数据才能被写入。

Gathering Writes能较好的处理动态消息。

在Java NIO中，如果两个通道中有一个是FileChannel，那你可以直接将数据从一个channel传输到另一个channel。

transferFrom()

FileChannel的transferFrom()方法可以将数据从源通道传输到FileChannel中。

RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel      fromChannel = fromFile.getChannel();

RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel      toChannel = toFile.getChannel();

long position = 0;
long count = fromChannel.size();

toChannel.transferFrom(position, count, fromChannel);

Selector(选择器)是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样一个单独的线程可以管理多个channel，从而管理多个网络连接。

为什么使用Selector

可以只用一个线程处理所有的通道。对于操作系统来说，线程之间上下文切换的开销很大，而且每个线程都要占用系统的一些资源。

下面是单线程使用一个Selector处理3个channel的示例：

Selector的创建

通过调用Selector.open()方法创建一个Selector，如下：

Selector selector = Selector.open();

向Selector注册通道

为了将Channel和Selector配合使用，必须将channel注册到selector上。通过SelectableChannel.register()方法来实现，如下：

channel.configureBlocking(false);
SelectionKey key = channel.register(selector, Selectionkey.OP_READ);

与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。

register()方法的第二个参数。这是一个interest集合，意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件：

• Connect
• Accept
• Read
• Write

某个channel成功连接到另一个服务器称为连接就绪。SelectionKey.OP_CONNECT

一个server socket channel准备好接收新进入的连接称为接收就绪。SelectionKey.OP_ACCEPT

一个有数据可读的通道可以说是读就绪。SelectionKey.OP_READ

等待写数据的通道可以说是写就绪。SelectionKey.OP_WRITE

如果你对不止一种事件感兴趣，那么可以用“位或”操作符将常量连接起来，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

当向Selector注册Channel时，register()方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性：

• interest集合
• ready集合
• Channel
• Selector
• 附加的对象（可选）

interest集合

interest集合是你所选择的感兴趣的事件集合。

可以通过SelectionKey读写interest集合：

int interestSet = selectionKey.interestOps();

boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

用'位与'操作interest集合和给定的selectionKey常量，可以确定某个确定的事件是否在interest集合中。

ready集合

ready集合是通道已经准备就绪的操作的集合。在一次选择（selection）之后，你会首先访问这个ready set。

int readySet = selectionKey.readyOps();

Channel + Selector

从SelectionKey访问Channel和Selector：

Channel  channel  = selectionKey.channel();
Selector selector = selectionKey.selector();

附加的对象

可以将一个对象或者更多信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。

例如，可以附加与通道一起使用的Buffer，或者包含聚集数据的某个对象，使用方法:

selectionKey.attach(theObject);
Object attachedObj = selectionKey.attachment();

还可以在用register()方法向Selector注册Channel的时候附加对象。

SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

通过Selector选择通道

一旦向Selector注册了一个或多个通道，就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件、已经准备就绪的那些通道。

也就是，如果你对'读就绪'的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。

• select()阻塞到至少有一个通道在你注册的事件上就绪了。

• select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。

• selectNow()不会阻塞，不管什么通道就绪都立刻返回（译者注：此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，则此方法直接返回零。）。

select()方法返回的int值表示有多少通道已经就绪。自上次调用select()方法后有多少通道变成就绪状态。

如果调用`select()`方法，因为有一个通道变成就绪状态，返回了1
若再次调用`select()`方法，如果另一个通道就绪了，它会再次返回1。

如果对第一个就绪的channel没有做任何操作，现在就有两个就绪的通道，
但在每次`select()`方法调用之间，只有一个通道就绪了。

selectedKeys()

一旦调用了select()方法，并且返回值表明有一个或者多个通道就绪了，然后可以通过调用selector的selectedKeys()方法，访问'已选择键集（selected key set）'中的就绪通道。如下所示：

Set selectedKeys = selector.selectedKeys();

当像Selector注册Channel时，Channel.register()方法会返回一个SelectionKey 对象。这个对象代表了注册到该Selector的通道。可以通过SelectionKey的selectedKeySet()方法访问这些对象。

Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove();
}

这个循环遍历已选择键集中的每个键，并检测各个键所对应的通道的就绪事件。

注意每次迭代末尾的keyIterator.remove()调用。Selector不会自己从已选择键集中移除SelectionKey实例。必须在处理完通道时自己移除。

SelectionKey.channel()方法返回的通道需要转型成你要处理的类型，如ServerSocketChannel或SocketChannel等。

wakeUp()

某个线程调用select()方法后阻塞了，即使没有通道已经就绪，也有办法让其从select()方法返回。只要让其它线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法即可。阻塞在select()方法上的线程会立马返回。

如果有其它线程调用了wakeup()方法，但当前没有线程阻塞在select()方法上，下个调用select()方法的线程会立即'醒来（wake up）'

close()

用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的所有SelectionKey实例无效。通道本身并不会关闭。

完整的示例

这里是一个完整的示例，打开一个Selector，注册一个通道注册到这个Selector上，然后持续监控这个Selector的四种事件（接受，连接，读，写）是否就绪

Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
while(true) {
  int readyChannels = selector.select();
  if(readyChannels == 0) continue;
  Set selectedKeys = selector.selectedKeys();
  Iterator keyIterator = selectedKeys.iterator();
  while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove();
  }
}

Reference

Channel和Buffer

基本上，所有的IO在NIO中都从一个Channel开始。

数据可以从Channel读到Buffer中，也可以从Buffer写到Channel中。

Selector

Selector允许单线程处理多个Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。

要使用Selector，得向Selector注册Channel，然后调用它的select（）方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，

Channel

Java NIO的通道类似流，但又有些不同：

• 既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。
• 通道可以异步地读写。
• 通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。

Channel的实现

这些是Java NIO中最重要的通道的实现：

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

FileChannel 从文件中读写数据。

DatagramChannel 能通过UDP读写网络中的数据。

SocketChannel 能通过TCP读写网络中的数据。

ServerSocketChannel可以监听新进来的TCP连接，像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。

基本的Channel示例

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

//create buffer with capacity of 48 bytes
ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buf); //read into buffer.
while (bytesRead != -1) 
{
  buf.flip();  //make buffer ready for read

  while(buf.hasRemaining())
  {
      System.out.print((char) buf.get()); // read 1 byte at a time
  }

  buf.clear(); //make buffer ready for writing
  bytesRead = inChannel.read(buf);
}
aFile.close();

注意buf.flip()的调用，首先读取数据到Buffer，然后反转Buffer，接着再从Buffer中读取数据。

Buffer

Java NIO中的Buffer用于和NIO通道进行交互。数据是从通道读入缓冲区，从缓冲区写入到通道中。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

Buffer的基本用法

使用Buffer读写数据一般遵循以下四个步骤：

1. 写入数据到buffer
2. 调用flip()方法
3. 从buffer中读取数据
4. 调用clear()方法或者compact()方法

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。

一旦读完了所有的数据，就需要清空缓冲区，让它们可以再次被写入。有两种方式能清空缓冲区：调用clear()或者compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

Buffer的capacity, position和limit

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。

capacity

作为一个内存块，Buffer有一个固定的大小值。一旦Buffer满了，需要将其清空（通过读数据或者清楚数据）才能继续写数据往里写数据。

position

当你写数据到Buffer中时，position表示当前的位置。初始的position值为0，当一个byte, long等数据写到Buffer后，position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity-1

当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0.当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

limit

在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。在写模式下，limit等于Buffer的capacity。

当切换Buffer到读模式的，limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。

Buffer的分配

要想获得一个Buffer对象首先要进行分配。每一个Buffer类都有一个allocate方法

向Buffer中写数据

写数据到Buffer有两种方式：

• 从Channel写到Buffer
• 通过Buffer的put()方法写到Buffer里

从Channel写到Buffer的例子

int bytesRead = inChannel.read(buf); // read into buffer

通过put方法写Buffer的例子：

buf.put(127);

flip()方法

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。

从Buffer中读取数据

从Buffer中读取数据有两种方式：

• 从Buffer读取数据到Channel
• 使用get()方法从Buffer中读取数据

从Buffer读取数据到Channel的例子

int bytesWritten = inChannel.write(buf);

使用get()方法从Buffer中读取数据的例子

byte aByte = buf.get();

rewind()方法

Buffer.rewind()将position设为0，所以你可以重读Buffer中的所有数据。limit保持不变，任何表示能从Buffer读取多少元素。

clear()与compact()方法

一旦读完Buffer中的数据，需要让Buffer准备好再次被写入。可以通过clear()或者compact()方法来完成。

如果调用的是clear()方法，position将被设回0，limit被设置为capacity的值。换句话说，Buffer被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。

如果Buffer中有一些未读的数据，调用clear()方法，数据将‘被遗忘’，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。

如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先写些数据，那么使用compact()方法

compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。

mark()和reset()方法

通过调用Buffer.mark()方法，可以标记Buffer中的一个特定position。之后可以通过调用Buffer.reset()方法恢复到这个position。

buffer.mark();
// call buffer.get() a couple of times, e.g. during parsing
buffer.reset();

equals()与compareTo()方法

equals()方法

当满足下列条件时，表示两个Buffer相等:

• 有相同的类型
• Buffer中剩余的byte、char等的个数相等
• Buffer中所有剩余的byte、char等都相同

equals只比较Buffer中的剩余元素

compareTo()方法

compareTo()方法比较两个Buffer的剩余元素。如果满足下列条件，则认为一个Buffer小于另一个Buffer：

• 第一个不相等的元素小于另一个Buffer中对应的元素
• 所有元素都相等，但第一个Buffer比另一个先耗尽（第一个Buffer的元素比另一个少）

Reference

为什么Redis不支持回滚（rollback）

• Redis命令只会因为错误的语法而失败，或者是命令用在了错误类型的键上
• 因为不需要对回滚进行支持，所以Redis的内部可以保持简单而快速

在通常情况下， 回滚并不能解决编程错误带来的问题。 举个例子， 如果你本来想通过 INCR 命令将键的值加上 1 ， 却不小心加上了 2 ， 又或者对错误类型的键执行了 INCR ， 回滚是没有办法处理这些情况的。

鉴于没有任何机制能避免程序员自己造成的错误， 并且这类错误通常不会在生产环境中出现， 所以 Redis 选择了更简单、更快速的无回滚方式来处理事务。

watch的作用是什么，跟直接用multi有什么区别

NIO入门

I/O简介

I/O指的是计算机与外部世界或者一个程序与计算机的其余部分之间的接口。

在Java编程中，直到最近一直使用流的方式完成I/O。所有I/O都被视为单个的字节的流动，通过一个称为Stream的对象一次移动一个字节。流I/O用于与外部世界接触。它也在内部使用，用于将对象转换为字节，然后再转换回对象。

NIO与原来的I/O有同样的作用和目的，但是它使用不同的方式：块I/O

块I/O的效率比流I/O高很多

流与块的比较

面向流的I/O系统一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器，以便每个过滤器只负责单个复杂处理机制的一部分。不利的一面是，面向流的I/O通常相当慢。

一个面向块的I/O系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据库。按块处理数据比按（流式的）字节处理数据要快得多。但是面向块的I/O缺少一些面向流的I/O所具有的优雅型和简单性。

通道和缓冲区是NIO中的核心对象，几乎在每一个I/O操作中都要使用它们。

通道是对原I/O包中的流的模拟。到任何目的地的所有数据都必须通过一个Channel对象。一个Buffer实质上是一个容器对象。发送给一个通道的所有对象都必须首先放到缓冲区中；同样地，从通道中读取的任何数据都要读到缓冲区中。

什么是缓冲区

Buffer是一个对象，它包含一些要写入或者刚读出的数据。

在面向流的I/O中，你是将数据直接写入或者将数据直接读到Stream对象中。

在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入缓冲区中的。

缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。

什么是通道

Channel是一个对象，可以通过它读取和写入数据。

所有数据都通过Buffer对象来处理。你不会将字节直接写入通道中，相反，你是将数据写入包含一个或者多个字节的缓冲区。

通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动（一个流必须是InputStream或者OutputStream的子类），而通道可以用于读、写或者同时用于读写。

从文件中读取

我们将从一个文件中读取一些数据。如果使用原来的 I/O，那么我们只需创建一个 FileInputStream 并从它那里读取。而在 NIO 中，情况稍有不同：我们首先从 FileInputStream 获取一个 Channel 对象，然后使用这个通道来读取数据。

在 NIO 系统中，任何时候执行一个读操作，您都是从通道中读取，但是您不是 直接 从通道读取。因为所有数据最终都驻留在缓冲区中，所以您是从通道读到缓冲区中。

因此读取文件涉及三个步骤：(1) 从 FileInputStream 获取 Channel，(2) 创建 Buffer，(3) 将数据从 Channel 读到 Buffer 中。

读文件

第一步是获取通道。我们从 FileInputStream 获取通道：

FileInputStream fin = new FileInputStream( "readandshow.txt" );
FileChannel fc = fin.getChannel();

下一步是创建缓冲区：

ByteBuffer buffer = ByteBuffer.allocate( 1024 );

最后，需要将数据从通道读到缓冲区中，如下所示：

fc.read( buffer );

我们不需要告诉通道要读多少数据到缓冲区中。

写入文件

首先从 FileOutputStream 获取一个通道：

FileOutputStream fout = new FileOutputStream( "writesomebytes.txt" );
FileChannel fc = fout.getChannel();

下一步是创建一个缓冲区并在其中放入一些数据 - 在这里，数据将从一个名为 message 的数组中取出，这个数组包含字符串 "Some bytes" 的 ASCII 字节(本教程后面将会解释 buffer.flip() 和 buffer.put() 调用)。

ByteBuffer buffer = ByteBuffer.allocate( 1024 );

for (int i=0; i<message.length; ++i) {
     buffer.put( message[i] );
}
buffer.flip();

最后一步是写入缓冲区中：

fc.write( buffer );

不需要告诉通道要写入多数据。

缓冲区内部细节

每一个读/写操作都会改变缓冲区的状态。通过记录和跟踪这些变化，缓冲区就能内部地管理自己的资源

状态变量

可以用三个值指定缓冲区在任意时刻的状态：

• position
• limit
• capacity

这三个变量一起可以跟踪缓冲区的状态和它所包含的数据。

Position

缓冲区实际上就是美化了的数组。在从通道读取是，你将所读取的数据放到底层的数组中。position变量跟踪已经写了多少数据，即它制定了下一个字节将放到数组的哪一个元素中。

limit

limit变量表面还有多少数据需要取出，或者还有多少空间可以放入数据

position 总是小于或者等于 limit

capacity

缓冲区的capacity表明可以储存在缓冲区中的最大数据容量。实际上，它指定了底层数组的大小，或者至少指定了准许我们使用的底层数组的容量

limit绝不能大于capacity

flip

flip() 方法。这个方法做两件非常重要的事：

• 它将 limit 设置为当前 position
• 它将 position 设置为 0

clear

clear() 方法。这个方法重设缓冲区以便接收更多的字节。 Clear 做两种非常重要的事情：

• 它将 limit 设置为与 capacity 相同。
• 它设置 position 为 0。

缓冲区分配和包装

在能够读和写之前，必须有一个缓冲区。要创建缓冲区，您必须 分配 它。我们使用静态方法 allocate() 来分配缓冲区：

ByteBuffer buffer = ByteBuffer.allocate( 1024 );

allocate() 方法分配一个具有指定大小的底层数组，并将它包装到一个缓冲区对象中 ― 在本例中是一个 ByteBuffer。
您还可以将一个现有的数组转换为缓冲区，如下所示：

byte array[] = new byte[1024];
ByteBuffer buffer = ByteBuffer.wrap( array );

缓冲区分片

slice()方法根据现有的缓冲区创建一种子缓冲区。也就是说，它创建一个新的缓冲区，新缓冲区与原来的缓冲区的一部分共享数据。

我们首先创建一个长度为 10 的 ByteBuffer：

ByteBuffer buffer = ByteBuffer.allocate( 10 );

然后使用数据来填充这个缓冲区，在第 n 个槽中放入数字 n：

for (int i=0; i<buffer.capacity(); ++i) {
     buffer.put( (byte)i );
}

现在我们对这个缓冲区 分片 ，以创建一个包含槽 3 到槽 6 的子缓冲区。在某种意义上，子缓冲区就像原来的缓冲区中的一个 窗口 。
窗口的起始和结束位置通过设置 position 和 limit 值来指定，然后调用 Buffer 的 slice() 方法：

buffer.position( 3 );
buffer.limit( 7 );
ByteBuffer slice = buffer.slice();

片 是缓冲区的 子缓冲区 。不过， 片段 和 缓冲区 共享同一个底层数据数组

缓冲区分片和数据共享

我们遍历子缓冲区，将每一个元素乘以 11 来改变它。例如，5 会变成 55。

for (int i=0; i<slice.capacity(); ++i) {
     byte b = slice.get( i );
     b *= 11;
     slice.put( i, b );
}

最后，再看一下原缓冲区中的内容：

buffer.position( 0 );
buffer.limit( buffer.capacity() );

while (buffer.remaining()>0) {
     System.out.println( buffer.get() );
}

结果表明只有在子缓冲区窗口中的元素被改变了：

$ java SliceBuffer
0
1
2
33
44
55
66
7
8
9

只读缓冲区

通过调用缓冲区的 asReadOnlyBuffer() 方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区(并与其共享数据)，只不过它是只读的。

直接和间接缓冲区

直接缓冲区 是为加快 I/O 速度，而以一种特殊的方式分配其内存的缓冲区。

内存映射文件I/O

内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。

将文件映射到内存

下面代码行将文件的前 1024 个字节映射到内存中：

MappedByteBuffer mbb = fc.map( FileChannel.MapMode.READ_WRITE,
    0, 1024 );

map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类

分散和聚集

分散/聚集 I/O 是使用多个而不是单个缓冲区来保存数据的读写方法。

文件锁定

要获取文件的一部分上的锁，您要调用一个打开的 FileChannel 上的 lock() 方法。注意，如果要获取一个排它锁，您必须以写方式打开文件。

RandomAccessFile raf = new RandomAccessFile( "usefilelocks.txt", "rw" );
FileChannel fc = raf.getChannel();
FileLock lock = fc.lock( start, end, false );

在拥有锁之后，您可以执行需要的任何敏感操作，然后再释放锁：

lock.release();

在释放锁后，尝试获得锁的其他任何程序都有机会获得它。

异步I/O

异步 I/O 是一种没有阻塞地读写数据的方法。通常，在代码进行 read() 调用时，代码会阻塞直至有可供读取的数据。同样， write() 调用将会阻塞直至数据能够写入。

异步 I/O 的一个优势在于，它允许您同时根据大量的输入和输出执行 I/O。同步程序常常要求助于轮询，或者创建许许多多的线程以处理大量的连接。使用异步 I/O，您可以监听任何数量的通道上的事件，不用轮询，也不用额外的线程。

异步 I/O 中的核心对象名为 Selector。Selector 就是您注册对各种 I/O 事件的兴趣的地方，而且当那些事件发生时，就是这个对象告诉您所发生的事件。

我们需要做的第一件事就是创建一个 Selector：

Selector selector = Selector.open();

然后，我们将对不同的通道对象调用 register() 方法，以便注册我们对这些对象中发生的 I/O 事件的兴趣。register() 的第一个参数总是这个 Selector。

为了接收连接，我们需要一个 ServerSocketChannel。事实上，我们要监听的每一个端口都需要有一个 ServerSocketChannel 。对于每一个端口，我们打开一个 ServerSocketChannel，如下所示：

ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking( false );

ServerSocket ss = ssc.socket();
InetSocketAddress address = new InetSocketAddress( ports[i] );
ss.bind( address );

第一行创建一个新的 ServerSocketChannel ，最后三行将它绑定到给定的端口。第二行将 ServerSocketChannel 设置为 非阻塞的 。

下一步是将新打开的 ServerSocketChannels 注册到 Selector上。为此我们使用 ServerSocketChannel.register() 方法，如下所示：

SelectionKey key = ssc.register( selector, SelectionKey.OP_ACCEPT );

SelectionKey 代表这个通道在此 Selector 上的这个注册。当某个 Selector 通知您某个传入事件时，它是通过提供对应于该事件的 SelectionKey 来进行的。SelectionKey 还可以用于取消通道的注册。

现在已经注册了我们对一些 I/O 事件的兴趣，下面将进入主循环。使用 Selectors 的几乎每个程序都像下面这样使用内部循环：

int num = selector.select();

Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();

while (it.hasNext()) {
     SelectionKey key = (SelectionKey)it.next();
     // ... deal with I/O event ...
}

首先，我们调用 Selector 的 select() 方法。这个方法会阻塞，直到至少有一个已注册的事件发生。当一个或者更多的事件发生时， select() 方法将返回所发生的事件的数量。
接下来，我们调用 Selector 的 selectedKeys() 方法，它返回发生了事件的 SelectionKey 对象的一个 集合 。
我们通过迭代 SelectionKeys 并依次处理每个 SelectionKey 来处理事件。对于每一个 SelectionKey，您必须确定发生的是什么 I/O 事件，以及这个事件影响哪些 I/O 对象。

因为我们知道这个服务器套接字上有一个传入连接在等待，所以可以安全地接受它；也就是说，不用担心 accept() 操作会阻塞：

ServerSocketChannel ssc = (ServerSocketChannel)key.channel();
SocketChannel sc = ssc.accept();

下一步是将新连接的 SocketChannel 配置为非阻塞的。而且由于接受这个连接的目的是为了读取来自套接字的数据，所以我们还必须将 SocketChannel 注册到 Selector上，如下所示：

sc.configureBlocking( false );
SelectionKey newKey = sc.register( selector, SelectionKey.OP_READ );

Reference

Tomcat

Server

Server是Tomcat中最顶层的组件，它可以包含多个Service组件。

在Tomcat源码中Server组件对应源码中的org.apache.catalina.core.StandardServer类

StandardServer的继承关系图如下图所示：

Service

Service组件相当于Connector和Engine组件的包装器，它将一个或者多个Connector组件和一个Engine建立关联。

在缺省的配置文件中，定义了一个叫Catalina的Service，并将Http，AJP这两个Connector关联到了一个名为Catalina的Engine。

Service组件对应Tomcat源码中的org.apache.catalina.core.StandardService

StandardService的继承关系图如下图所示：

Connector

Connector是Tomcat中监听TCP网络连接的组件，一个Connector会监听一个独立的端口来处理来自客户端的连接。

缺省的情况下Tomcat提供了如下两个Connector：

• HTTP/1.1

  <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />
  

  上面定义了一个Connector，它缺省监听端口8080,这个端口我们可以根据具体情况进行改动。connectionTimeout定义了连接超时时间，单位是毫秒，redirectPort定义了ssl的重定向接口，根据缺省的配置，Connector会将ssl请求重定向到8443端口。

• AJP/1.3

  AJP表示Apache Jserv Protocol,此连接器将处理Tomcat和Aapache http服务器之间的交互，这个连机器是用来处理我们将Tomcat和Apache http服务器结合使用的情况。假如在同样的一台物理Server上面部署了一台Apache http服务器和多台Tomcat服务器，通过Apache服务器来处理静态资源以及负载均衡的时候，针对不同的Tomcat实例需要AJP监听不同的端口。

Connector对应源代码中的org.apache.catalina.connector.Connector

它的继承关系图如下所示：

Engine

Tomcat中有一个容器的概念，而Engine，Host，Context都属于Container。

一个Engine可以包含一个或者多个Host，也就是说我们一个Tomcat的实例可以配置多个虚拟主机。

缺省的情况下<Engine name="Catalina" defaultHost="localhost">定义了一个名称为Cataline的Engine。

Engine对应源代码中的org.apache.catalina.core.StandardEngine

它的继承关系图如下图所示：

Host

Host定义了一个虚拟主机，一个虚拟主机可以有多个Context。

缺省的配置为<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">….</Host>

其中appBase为webapps，也就是<CATALINA_HOME>\webapps目录

unpackingWARS属性指定在appBase指定的目录中的war包都自动的解压，缺省配置为true

autoDeploy属性指定是否对加入到appBase目录的war包进行自动的部署，缺省为true。

Host对应源代码中的org.apache.catalina.core.StandardHost,它的继承关系图如下所示：

Context

在Tomcat中，每一个运行的webapp其实最终都是以Context的形成存在，每个Context都有一个根路径和请求URL路径。

Context对应源代码中的org.apache.catalina.core.StandardContext。

它的继承关系图如下图所示：

在Tomcat中我们通常采用如下的两种方式创建一个Context