`
tenyears
  • 浏览: 206709 次
  • 性别: Icon_minigender_1
  • 来自: 湖北武汉
文章分类
社区版块
存档分类
最新评论

使用Java NIO编写高性能的服务器

Java多线程SocketTomcat.net 
阅读更多

从JDK 1.4开始，Java的标准库中就包含了NIO，即所谓的“New IO”。其中最重要的功能就是提供了“非阻塞”的IO，当然包括了Socket。NonBlocking的IO就是对select(Unix平台下)以及 WaitForMultipleObjects(Windows平台)的封装，提供了高性能、易伸缩的服务架构。

说来惭愧，直到JDK1.4才有这种功能，但迟到者不一定没有螃蟹吃，NIO就提供了优秀的面向对象的解决方案，可以很方便地编写高性能的服务器。

话说回来，传统的Server/Client实现是基于Thread per request，即服务器为每个客户端请求建立一个线程处理，单独负责处理一个客户的请求。比如像Tomcat（新版本也会提供NIO方案）、Resin等Web服务器就是这样实现的。当然为了减少瞬间峰值问题，服务器一般都使用线程池，规定了同时并发的最大数量，避免了线程的无限增长。

但这样有一个问题：如果线程池的大小为100，当有100个用户同时通过HTTP现在一个大文件时，服务器的线程池会用完，因为所有的线程都在传输大文件了，即使第101个请求者仅仅请求一个只有10字节的页面，服务器也无法响应了，只有等到线程池中有空闲的线程出现。

另外，线程的开销也是很大的，特别是达到了一个临界值后，性能会显著下降，这也限制了传统的Socket方案无法应对并发量大的场合，而“非阻塞”的IO就能轻松解决这个问题。

下面只是一个简单的例子：服务器提供了下载大型文件的功能，客户端连接上服务器的12345端口后，就可以读取服务器发送的文件内容信息了。注意这里的服务器只有一个主线程，没有其他任何派生线程，让我们看看NIO是如何用一个线程处理N个请求的。

NIO服务器最核心的一点就是反应器模式：当有感兴趣的事件发生的，就通知对应的事件处理器去处理这个事件，如果没有，则不处理。所以使用一个线程做轮询就可以了。当然这里这是个例子，如果要获得更高性能，可以使用少量的线程，一个负责接收请求，其他的负责处理请求，特别是对于多CPU时效率会更高。

关于使用NIO过程中出现的问题，最为普遍的就是为什么没有请求时CPU的占用率为100%？出现这种问题的主要原因是注册了不感兴趣的事件，比如如果没有数据要发到客户端，而又注册了写事件（OP_WRITE），则在 Selector.select()上就会始终有事件出现，CPU就一直处理了，而此时select()应该是阻塞的。

另外一个值得注意的问题是：由于只使用了一个线程（多个线程也如此）处理用户请求，所以要避免线程被阻塞，解决方法是事件的处理者必须要即刻返回，不能陷入循环中，否则会影响其他用户的请求速度。

具体到本例子中，由于文件比较大，如果一次性发送整个文件（这里的一次性不是指send整个文件内容，而是通过while循环不间断的发送分组包），则主线程就会阻塞，其他用户就不能响应了。这里的解决方法是当有WRITE事件时，仅仅是发送一个块（比如4K字节）。发完后，继续等待WRITE事件出现，依次处理，直到整个文件发送完毕，这样就不会阻塞其他用户了。

服务器的例子：

package nio.file;

import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;

/**
 * 测试文件下载的NIOServer
 * 
 * @author tenyears.cn
 */
public class NIOServer {
  static int BLOCK = 4096;
  // 处理与客户端的交互
  public class HandleClient {
    protected FileChannel channel;
    protected ByteBuffer buffer;
    public HandleClient() throws IOException {
      this.channel = new FileInputStream(filename).getChannel();
      this.buffer = ByteBuffer.allocate(BLOCK);
    }
    public ByteBuffer readBlock() {
      try {
        buffer.clear();
        int count = channel.read(buffer);
        buffer.flip();
        if (count <= 0)
          return null;
      } catch (IOException e) {
        e.printStackTrace();
      }
      return buffer;
    }
    public void close() {
      try {
        channel.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }

  protected Selector selector;
  protected String filename = "d:\\bigfile.dat"; // a big file
  protected ByteBuffer clientBuffer = ByteBuffer.allocate(BLOCK);
  protected CharsetDecoder decoder;

  public NIOServer(int port) throws IOException {
    selector = this.getSelector(port);
    Charset charset = Charset.forName("GB2312");
    decoder = charset.newDecoder();
  }

  // 获取Selector
  protected Selector getSelector(int port) throws IOException {
    ServerSocketChannel server = ServerSocketChannel.open();
    Selector sel = Selector.open();
    server.socket().bind(new InetSocketAddress(port));
    server.configureBlocking(false);
    server.register(sel, SelectionKey.OP_ACCEPT);
    return sel;
  }

  // 监听端口
  public void listen() {
    try {
      for (;;) {
        selector.select();
        Iterator<selectionkey></selectionkey> iter = selector.selectedKeys()
            .iterator();
        while (iter.hasNext()) {
          SelectionKey key = iter.next();
          iter.remove();
          handleKey(key);
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  // 处理事件
  protected void handleKey(SelectionKey key) throws IOException {
    if (key.isAcceptable()) { // 接收请求
      ServerSocketChannel server = (ServerSocketChannel) key.channel();
      SocketChannel channel = server.accept();
      channel.configureBlocking(false);
      channel.register(selector, SelectionKey.OP_READ);
    } else if (key.isReadable()) { // 读信息
      SocketChannel channel = (SocketChannel) key.channel();
      int count = channel.read(clientBuffer);
      if (count > 0) {
        clientBuffer.flip();
        CharBuffer charBuffer = decoder.decode(clientBuffer);
        System.out.println("Client >>" + charBuffer.toString());
        SelectionKey wKey = channel.register(selector,
            SelectionKey.OP_WRITE);
        wKey.attach(new HandleClient());
      } else
        channel.close();
      clientBuffer.clear();
    } else if (key.isWritable()) { // 写事件
      SocketChannel channel = (SocketChannel) key.channel();
      HandleClient handle = (HandleClient) key.attachment();
      ByteBuffer block = handle.readBlock();
      if (block != null)
        channel.write(block);
      else {
        handle.close();
        channel.close();
      }
    }
  }

  public static void main(String[] args) {
    int port = 12345;
    try {
      NIOServer server = new NIOServer(port);
      System.out.println("Listernint on " + port);
      while (true) {
        server.listen();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

该代码中，通过一个HandleClient来获取文件的一块数据，每一个客户都会分配一个HandleClient的实例。

下面是客户端请求的代码，也比较简单，模拟100个用户同时下载文件。

package nio.file;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 文件下载客户端
 * @author tenyears.cn
 */
public class NIOClient {
  static int SIZE = 100;
  static InetSocketAddress ip = new InetSocketAddress("localhost",12345);
  static CharsetEncoder encoder = Charset.forName("GB2312").newEncoder();
  static class Download implements Runnable {
    protected int index;
    public Download(int index) {
      this.index = index;
    }

    public void run() {
      try {
        long start = System.currentTimeMillis();
        SocketChannel client = SocketChannel.open();
        client.configureBlocking(false);
        Selector selector = Selector.open();
        client.register(selector, SelectionKey.OP_CONNECT);
        client.connect(ip);
        ByteBuffer buffer = ByteBuffer.allocate(8 * 1024);
        int total = 0;
        FOR: for (;;) {
          selector.select();
          Iterator<selectionkey></selectionkey> iter = selector.selectedKeys()
              .iterator();
          while (iter.hasNext()) {
            SelectionKey key = iter.next();
            iter.remove();
            if (key.isConnectable()) {
              SocketChannel channel = (SocketChannel) key
                  .channel();
              if (channel.isConnectionPending())
                channel.finishConnect();
              channel.write(encoder.encode(CharBuffer
                  .wrap("Hello from " + index)));
              channel.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
              SocketChannel channel = (SocketChannel) key
                  .channel();
              int count = channel.read(buffer);
              if (count > 0) {
                total += count;
                buffer.clear();
              } else {
                client.close();
                break FOR;
              }
            }
          }
        }
        double last = (System.currentTimeMillis() - start) * 1.0 / 1000;
        System.out.println("Thread " + index + " downloaded " + total
            + "bytes in " + last + "s.");
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) throws IOException {
    ExecutorService exec = Executors.newFixedThreadPool(SIZE);
    for (int index = 0; index < SIZE; index++) {
      exec.execute(new Download(index));
    }
    exec.shutdown();
  }
}
分享到：
评论
6 楼 sxjkk 2012-06-28  
楼主...格式化下代码，要不看起费劲
5 楼 zzming630 2012-06-06  
xuhang1128 写道
谢谢，找了很多文章，感觉这个最实用了

同感，易读性比其他文章强
4 楼 zhdkn 2012-02-20  
正在学习NIO，好的开头，谢谢lz的介绍，看完后收了
3 楼 xuhang1128 2011-11-12  
谢谢，找了很多文章，感觉这个最实用了
2 楼 Arbow 2007-07-25  
gh_aiyz 写道
CharsetDecorder并不是线程安全的，在高并发的状态下会出问题。


是的，所以一般使用ThreadLocal来保存CharsetDecoder的实例，例子可以参照cindy 2.x的CharsetUtils.java
1 楼 gh_aiyz 2007-07-25  
CharsetDecorder并不是线程安全的，在高并发的状态下会出问题。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    使用Java_NIO编写高性能的服务器.doc

    ### 使用Java NIO编写高性能服务器的关键知识点 #### 一、NIO概述 - **NIO简介**：NIO（New IO）自JDK 1.4引入以来，为Java提供了非阻塞IO的支持，这对于提高服务端应用的性能至关重要。NIO的核心特性包括缓冲区...

    高手使用Java NIO编写高性能的服务器

    在高性能服务器开发中，Java NIO扮演着至关重要的角色。传统的IO模型在高并发场景下，由于每个连接都需要一个线程来处理，当连接数量增加时，线程数量也随之增加，最终可能导致系统资源耗尽。而NIO通过选择器...

    使用Java NIO编写高性能的服务器.doc

    服务器使用ServerSocketChannel监听特定端口，SocketChannel代表客户端连接。当有新的连接请求到达时，服务器创建一个ByteBuffer用于读取文件内容，并将其发送给客户端。在处理过程中，服务器需要注意避免阻塞，例如...

    Java NIO Socket基本

    NIO在实际开发中常用于构建高性能的网络服务器，如Tomcat、Netty等框架就大量使用了NIO技术。通过合理使用NIO，开发者可以编写出更加高效、可扩展的服务端代码。了解和掌握Java NIO对于提升Java程序员在服务器端编程...

    java nio入门学习，两个pdf

    1. **高并发服务器**：NIO在开发高性能、大并发的服务器时非常有用，例如聊天服务器、游戏服务器等。 2. **文件操作**：NIO提供了高效、灵活的文件读写能力，特别是对于大数据处理，如日志分析、文件复制等。 3. *...

    Java NIO Ron Hitchens著

    10. **案例分析**：书中可能会通过实际的案例来展示如何使用NIO构建高性能的网络服务器，或者优化文件读写操作。 《Java NIO》这本书对于理解和掌握Java NIO技术至关重要，无论你是Java开发者还是系统架构师，都能...

    Java语言基础教程-Java NIO流篇2

    总之，Java NIO流和通道的使用能显著提升Java应用的I/O性能，尤其在处理高并发和大数据量的场景下。通过本教程的学习，开发者不仅可以掌握NIO的基本概念，还能了解其在实际开发中的应用，为编写高效、灵活的Java程序...

    JAVA高性能高并发服务器架构pdf文档视频资源

    Netty框架是一个优秀的NIO库，广泛应用于高性能服务器开发。 "服务器架构"这部分，通常涉及如何设计和组织服务器的各个组件，以确保可扩展性、稳定性和性能。常见的服务器架构有微服务架构、SOA（Service-Oriented ...

    基于Java NIO反应器模式设计与实现

    Mina是一个完全由Java编写的NIO框架，而Netty则是由JBOSS提供的一个高性能的异步事件驱动的网络应用框架，它们都是基于Java反应器模式设计的，用于处理大量并发连接的场景。 综上所述，基于Java NIO的反应器模式...

    《Java NIO》Download Url

    通过学习《Java NIO》，开发者可以掌握如何构建高性能、低延迟的网络应用，特别是在处理大数据、分布式系统和高并发场景时，NIO的优势尤为突出。配合Java的并发工具和设计模式，可以编写出更加健壮和高效的服务器端...

    Java NIO原理分析及代码实例

    Java NIO（New IO）是Java...通过以上介绍的知识点，你可以开始编写基于NIO的应用，例如使用SocketChannel实现一个简单的非阻塞服务器。在实际编码时，参考博文链接中的代码实例，可以帮助你更好地理解和实践Java NIO。

    java nio 写文件

    Java NIO（New IO）是Java 1.4版本引入的一个新特性，它为Java提供了新的I/O操作方式，与传统的Java IO相比，NIO具有更高效、更灵活的特性，尤其是在处理大量并发I/O操作时。本篇将详细探讨Java NIO在写文件方面的...

    Java NIO 中文版.rar

    在实际开发中，NIO常被应用于网络编程、文件系统操作以及高性能服务器的设计等领域。例如，使用NIO可以构建一个简单的聊天服务器，或者创建一个处理大量并发HTTP请求的Web服务器。通过深入理解NIO，你可以更好地优化...

Magicbox
Global site tag (gtag.js) - Google Analytics