Java非阻塞IO实战-优快云博客

本文介绍了一种利用Java非阻塞IO提升服务器性能的方法。通过一个具体的例子展示了如何使用非阻塞IO来处理多个客户端连接请求，仅需少量线程即可应对大量并发连接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java 非阻塞IO常用于高性能的服务器程序。对于阻塞式IO常常需要多个线程来处理客户端的请求，由于线程的开销较大，往往使服务器性能下降很快。而非阻塞IO只需几个线程就可以胜任大量的请求。对于p2p软件(例如BT软件),也常常使用非阻塞IO，来实现文件交换。

下面是一个典型的非阻塞IO程序。客户端向服务器端发起10个连接，服务器端向每个客户端发送”Hello”，并打印出来。

服务器端程序：

import java.io.IOException;

import java.net.InetSocketAddress;

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 Server {

// 服务器端口

public static int port = 9994;

public Server() {

init();

}

public void init() {

Selector selector = null;

try {

// 获得Selector实例

selector = Selector.open();

// 获得ServerSocketChannel实例

ServerSocketChannel serverChannel = ServerSocketChannel.open();

InetSocketAddress add = new InetSocketAddress("localhost", port);

// 设为非阻塞模式，默认为阻塞模式

serverChannel.configureBlocking(false);

// channel与一个InetSocketAddress绑定

serverChannel.socket().bind(add);

// 向selector注册

serverChannel.register(selector, SelectionKey.OP_ACCEPT);

} catch (IOException e) {

e.printStackTrace();

return;

}

while (true) {

try {

// 如果没有准备好的channel，就在这一直阻塞

// 注意刚启动时，没有客户端与服务器端连接，会阻塞

selector.select();

} catch (IOException e) {

e.printStackTrace();

break;

}

// 返回已经就绪的SelctionKey，然后迭代执行

Set readyKeys = selector.selectedKeys();

for (Iterator it = readyKeys.iterator(); it.hasNext();) {

SelectionKey key = (SelectionKey) it.next();

// 为防止重复迭代要执行remove，在执行selector.select()时，会自动加入去掉的key

it.remove();

try {

// 对应于注册的OP_ACCEPT管道，在这里即ServerSocketChannel

if (key.isAcceptable()) {

ServerSocketChannel server = (ServerSocketChannel) key

.channel();

// 由于ServerSocketChannel为非阻塞模式，因此不会在这阻塞

SocketChannel client = server.accept();

client.configureBlocking(false);

// 表明接受到一个客户端连接，将其注册到selector

// 执行selector.select()时可以自动选一个channel

client.register(selector, SelectionKey.OP_WRITE);

// 对应于注册的OP_WRITE管道，在这里即SocketChannel

} else if (key.isWritable()) {

SocketChannel client = (SocketChannel) key.channel();

// 开辟20个字节的缓冲区

ByteBuffer buffer = ByteBuffer.allocate(20);

String str = "hello";

// 将"hello"封装到buffer

buffer = ByteBuffer.wrap(str.getBytes());

// 写入客户端

client.write(buffer);

// 写完hello后取消通道的注册

key.cancel();

}

} catch (IOException e) {

e.printStackTrace();

key.cancel();

try {

// 关闭通道

key.channel().close();

} catch (IOException e1) {

e.printStackTrace();

}

}// end for

}// end while

}

public static void main(String[] args) {

Server server = new Server();

}

客户端程序：

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.SocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.SocketChannel;

public class Client ...{

    public Client() ...{

       init();

    }

    public void init() ...{

        try ...{

           SocketAddress add = new InetSocketAddress("localhost", Server.port);

           // 返回SocketChannel实例，并绑定SocketAddress

           SocketChannel client = SocketChannel.open(add);

           client.configureBlocking(false);

           ByteBuffer buffer = ByteBuffer.allocate(20);

                                        // 从通道中读取

           client.read(buffer);

                     // 为读取做准备

           buffer.flip();

           String result = "";

           // 每次读一个字符

           while (buffer.hasRemaining())

              result += String.valueOf((char) buffer.get());

           System.out.println(result);

           client.close();

       } catch (IOException e) ...{

           e.printStackTrace();

       }

    }

    public static void main(String[] args) ...{



       Client client=null;

       for(int i=0;i<10;i++)...{

          client = new Client();

          System.out.println("client "+i+" has connected");

       }

    }

}