对于应用服务器来说，性能是非常重要的，基本可以说决定着这款应用服务器的未来。通常从软件角度来说，应用服务器性能包括如下几个方面：
1、请求处理的并发程度，当前主流服务器均采用异步的方式处理客户端的请求；
2、减少网络传输的数据量，提高网络利用率；
3、降低新建网络链接的开销，以实现链接在多个请求之间的复用；
4、选择合适的I/O方式，例如NIO等。
一、阻塞与非阻塞、同步与异步
------同步：发出一个调用时，没有得到结果之前，该调用不返回，由调用者主动等待调用结果。
|
关注的是消息通信机制---------------------|
|
------异步：调用发出之后，调用直接返回，此时不会拿到返回结果。被调用者通过状态通知调用者或回调函数处理这个调用。 ------阻塞：调用结果返回之前，当前线程会被挂起。
|
关注的是程序在等待调用结果时的状态---------|
|
------非阻塞：调用返回结果之前，当前线程不会被挂起。
二、BIO
概念：bio基于流，是同步阻塞IO模式，数据的读取写入必须阻塞在一个线程内等待其完成。这里使用那个经典的烧开水例子，这里假设一个烧开水的场景，有一排水壶在烧开水，BIO的工作模式就是， 叫一个线程停留在一个水壶那，直到这个水壶烧开，才去处理下一 个水壶。但是实际上线程在等待水壶烧开的时间段什么都没有做。不知道io操作中什么时候有数据可读，所以一直是阻塞的模式。
缺点：当并发数达到一定量时，并且服务端需要一定的时间去处理请求时，例如1-2s，这时需要开启非常多的线程数，并且这些线程啥事不干，都是等着请求返回，大大浪费了系统资源，而且在线程切换上下文的过程中，也会浪费很多的资源
BIO是阻塞式I/O，通过socket在客户端与服务端建立双向链接以实现通信，主要步骤如下：
- a、服务端监听某个端口是否有链接请求；
- b、客户端向服务端发出链接请求；
- c、服务端向客户端返回accept()消息，此时链接成功；
- d、客户端和服务端通过send()、write()等方法与对方通信；
- e、关闭链接
eg：简单的网络通信如下：
服务端：
客户端：
这种简单的示例只支持一个客户端链接到一个服务端，现实情况是N个客户端链接到服务端。Tomcat是这么实现的：
三、NIO
概念：bio的性能是相对较差的，在NIO中，基于块的概念，可以在不编写本地代码的情况下利用底层优化。
NIO结构图：
来个复杂点的：
selectionKey则是用来描述相关事件。
1、通道(channel)
2、缓冲区(buffer)
3、选择器(selector)
简单的NIO示例：
服务端：NIOServer
package com.ty.server; 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 NIOServer { /**
* 定义服务端的selector，
* 主要作用：
* 1、将各种事件注册到selector中，selector监控各种事件的发生，例如accept、read等
* 2、将不同事件分配到不同的channel
*/
private Selector selector; //服务端初始化
public void init() throws IOException {
//创建一个selector对象
this.selector = Selector.open();
//创建serverSocketChanel对象
ServerSocketChannel serverSocketChanel = ServerSocketChannel.open();
//设置为非阻塞
serverSocketChanel.configureBlocking(false);
//通过serverSocketChannel对象获取serverSocket
ServerSocket serverSocket = serverSocketChanel.socket();
//绑定端口
InetSocketAddress address = new InetSocketAddress(8080);
serverSocket.bind(address);
//注册accept事件到selector中，accept用于获取客户端请求
serverSocketChanel.register(selector, SelectionKey.OP_ACCEPT);
} //服务端启动服务
public void start() throws IOException {
//这地方只做一个最简单的示例，不考虑服务端stop
while(true) {
/**
* selector监控客户端是否有对应事件发生，例如accept、read等等。
* 注：此方法是阻塞的，当客户端一直没有事件触发，线程一直挂起，直到至少有一事件触发，走后续流程
*/
selector.select(); //获取该selector监控到的所有触发的事件
Set<SelectionKey> selectionKeys = selector.selectedKeys();
//拿到迭代器，循环所有监控到的事件
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while(iterator.hasNext()) {
//事件用SelectionKey描述，主要包括connect、accept、read、write事件
SelectionKey selectionKey = iterator.next();
//每种事件只处理一次，避免重复处理
iterator.remove();
if(selectionKey.isAcceptable()) {
accept(selectionKey);
}
if(selectionKey.isReadable()) {
read(selectionKey);
}
}
}
} private void accept(SelectionKey selectionKey) throws IOException {
/**
* 从selectionkey中获取serverSocketChannel。
* ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 就像标准IO中的ServerSocket一样
*/
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey.channel();
//serverSocketChannel监听到新连接后，会创建socketChannel。获取socketChannel
SocketChannel socketChannel = serverSocketChannel.accept();
//设置为非阻塞
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ);
} private void read(SelectionKey selectionKey) throws IOException {
/**
* SocketChannel是一个连接到TCP网络套接字的通道，就像标准IO中的socket
* 创建方式：可以通过以下2种方式创建SocketChannel
* 1、打开一个SocketChannel并连接到互联网上的某台服务器。
* 2、一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。
*/
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
//创建读取缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
//通过socketChannel.read()获取客户端的请求数据
socketChannel.read(byteBuffer);
String request = new String(byteBuffer.array()).trim();
System.out.println("客户端发送的请求为：" + request);
//将一个数组包装成ByteBuffer
ByteBuffer outBuffer = ByteBuffer.wrap("请求收到啦！".getBytes());
//数据发送到客户端
socketChannel.write(outBuffer);
} public static void main(String[] args) throws IOException {
NIOServer server = new NIOServer();
server.init();
server.start();
}
}
客户端：NIOClient
package com.ty.client; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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; public class NIOClient { private Selector selector; private BufferedReader clientInput = new BufferedReader(new InputStreamReader(System.in)); public void init() throws IOException {
//创建selector
this.selector = Selector.open();
//创建SocketChannel
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
//注册connect事件
socketChannel.register(selector, SelectionKey.OP_CONNECT);
} public void start() throws IOException {
while(true) {
selector.select();
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while(iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
iterator.remove();
if(selectionKey.isConnectable()) {
connect(selectionKey);
}
if(selectionKey.isReadable()) {
read(selectionKey);
}
}
}
} public void connect(SelectionKey selectionKey) throws IOException {
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
//如果客户端正在链接
if(socketChannel.isConnectionPending()) {
//如果客户端已经链接成功
if(socketChannel.finishConnect()) {
socketChannel.configureBlocking(false);
//链接成功后自然要获取服务端的返回，因此注册read事件
socketChannel.register(selector, SelectionKey.OP_READ);
String request = clientInput.readLine();
//数据发送到服务端
socketChannel.write(ByteBuffer.wrap(request.getBytes()));
}else {
//事件未注册成功，取消掉
selectionKey.cancel();
}
}
} public void read(SelectionKey selectionKey) throws IOException {
//socketChannel与服务端的对应，双方友好建立一个通道
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
socketChannel.read(byteBuffer);
System.out.println("服务端响应为：" + new String(byteBuffer.array()).trim());
String request = clientInput.readLine();
socketChannel.write(ByteBuffer.wrap(request.getBytes()));
} public static void main(String[] args) throws IOException {
NIOClient client = new NIOClient();
client.init();
client.start();
}
}
测试结果：
服务端：
客户端：
这样通过NIO，客户端与服务端即可正常通信。
Tomcat中的NIO实现：