一。 thread-per-connection

The thread-per-connection approach uses an exclusive worker thread for each connection. Within the handling loop, a worker thread

waits for new incoming data, processes the request, returns the response data, and calls the blocking socket's read method

public class Server {
private ExecutorService executors = Executors.newFixedThreadPool(10);
private boolean isRunning = true; public static void main(String... args) throws ... {
new Server().launch(Integer.parseInt(args[0]));
} public void launch(int port) throws ... {
ServerSocket sso = new ServerSocket(port);
while (isRunning) {
Socket s = sso.accept();
executors.execute(new Worker(s));
}
} private class Worker implements Runnable {
private LineNumberReader in = null; Worker(Socket s) throws ... {
in = new LineNumberReader(new InputStreamReader(...));
out = ...
} public void run() {
while (isRunning) {
try {
// blocking read of a request (line)
String request = in.readLine(); // processing the request
String response = ... // return the response
out.write(resonse);
out.flush();
} catch (Exception e ) {
...
}
}
in.close();
...
}
}
}

Because each connection has an associated thread waiting on the server side, very good response times can be achieved. However,

higher loads require a higher number of running, concurrent threads, which limits scalability. In particular, long-living connections

like persistent HTTP connections lead to a lot of concurrent worker threads, which tend to waste their time waiting concurrent

threads can waste a great deal of stack space. Note, for example, that the default Java thread stack size for Solaris is 512 KB.

二。thread-on-event

If a readiness event occurs, an event handler will be notified to perform the appropriate processing within dedicated worker threads.

To participate in the event architecture, the connection's Channel has to be registered on a Selector. This will be done by calling

the register method. Although this method is part of the SocketChannel, the channel will be registered on the Selector, not the

other way around.

SocketChannel channel = serverChannel.accept();
channel.configureBlocking(false); // register the connection
SelectionKey sk = channel.register(selector, SelectionKey.OP_READ);

To detect new events, the Selector provides the capability to ask the registered channels for their readiness events. By calling the select

method, the Selector collects the readiness events of the registered channels. This method call blocks until at least one event has been

occurred. In this case, the method returns the number of connections that have become ready for I/O operations since the last select call.

The selected connections can be retrieved by calling the Selector's selectedKey method. This method returns a set of SelectionKey objects,

which holds the IO event status and the reference of the connection's Channel.

Selector is held by the Dispatcher. This is a single-threaded active class that surrounds the Selector. The Dispatcher is responsible to

retrieve the events and to dispatch the handling of the consumed events to the EventHandler.

Within the dispatch loop, the Dispatcher calls the Selector's select method to wait for new events. If at least one event has been occurred,

the method call returns and the associated channel for each event can be acquired by calling the selectedKeys method.

while (isRunning) {
// blocking call, to wait for new readiness events
int eventCount = selector.select(); // get the events
  Iterator it = selector.selectedKeys().iterator();
  while (it.hasNext()) {
SelectionKey key = it.next();
it.remove(); // readable event?
if (key.isValid() && key.isReadable()) {
eventHandler.onReadableEvent(key.channel());
} // writable event?
if (key.isValid() && key.isWritable()) {
key.interestOps(SelectionKey.OP_READ); // reset to read only
eventHandler.onWriteableEvent(key.channel());
}
...
}
...
}

Because worker threads are not forced to waste time by waiting for new requests to open a connection, the scalability and

throughput of this approach is conceptually only limited by system resources like CPU or memory. That said, the response

times wouldn't be as good as for the thread-per-connection approach, because of the required thread switches and

synchronization. The challenge of the event-driven approach is therefore to minimize synchronizations and optimize thread

management, so that this overhead will be negligible.

三。构成

1.Acceptor

The Acceptor is a single threaded active class. Because it is only responsible for handling the very short-running
client connection request, it is often sufficient to implement the Acceptor using the blocking I/O model.

class Acceptor implements Runnable {
...
void init() {
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(true);
serverChannel.socket().bind(new InetSocketAddress(serverPort));
} public void run() {
while (isRunning) {
try {
SocketChannel channel = serverChannel.accept(); Connection con = new Connection(channel, appHandler);
dispatcherPool.nextDispatcher().register(con);
} catch (...) {
...
}
}
}
}

2.Dispatcher

Because the scalability of a single Dispatcher is limited, often a small pool of Dispatchers will be used. One reason for this limitation

is the operating-system-specific implementation of the Selector.

Most popular operating systems map a SocketChannel to a file handle in a one-to-one relationship. Depending on the concrete system,

the maximum number of file handles per Selector is limited in adifferent way.

The Selector manages the registered channels internally by using key sets. This means that by registering a channel, an associated

SelectionKey will be created and be added to the Selector's registered key set. At the same time, the concurrent dispatcher thread

could call the Selector's select method, which also accesses the key set.

Because the key sets are not thread-safe, an unsynchronized registration in the context of the Acceptor thread can lead to deadlocks

and race conditions. This can be solved by implementing the selector guard object idiom, which allows suspending the dispatcher

thread temporarily.

class Dispatcher implements Runnable {
private Object guard = new Object();
… void register(Connection con) {
// retrieve the guard lock and wake up the dispatcher thread
// to register the connection's channel
synchronized (guard) {
selector.wakeup();
con.getChannel().register(selector, SelectionKey.OP_READ, con);
} // notify the application EventHandler about the new connection
} void announceWriteNeed(Connection con) {
SelectionKey key = con.getChannel().keyFor(selector);
synchronized (guard) {
selector.wakeup();
key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
}
} public void run() {
while (isRunning) {
synchronized (guard) {
// suspend the dispatcher thead if guard is locked
}
int eventCount = selector.select(); Iterator it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
it.remove(); // read event?
if (key.isValid() && key.isReadable()) {
Connection con = (Connection) key.attachment();
disptacherEventHandler.onReadableEvent(con);
} // write event?
}
}
}
}

4.Dispatcher-Level EventHandler

5.Application-Level EventHandler

 

Architecture of a Highly Scalable NIO-Based Server的更多相关文章

  1. Java NIO: Non-blocking Server 非阻塞网络服务器

    本文翻译自 Jakob Jenkov 的 Java NIO: Non-blocking Server ,原文地址:http://tutorials.jenkov.com/java-nio/non-bl ...

  2. Java NIO: Non-blocking Server

    Even if you understand how the Java NIO non-blocking features work (Selector, Channel, Buffer etc.), ...

  3. NIO的一些相关链接

    Architecture of a Highly Scalable NIO-Based Server Scalable IO in Java Tricks and Tips with NIO part ...

  4. 高吞吐高并发Java NIO服务的架构(NIO架构及应用之一)

    高吞吐高并发Java NIO服务的架构(NIO架构及应用之一) http://maoyidao.iteye.com/blog/1149015   Java NIO成功的应用在了各种分布式.即时通信和中 ...

  5. 如何设计scalable 的系统 (转载)

    Design a Scalable System Design a system that scales to millions of users (AWS based) Step 1: Outlin ...

  6. Cross-Domain Security For Data Vault

    Cross-domain security for data vault is described. At least one database is accessible from a plural ...

  7. 可扩展的Web系统和分布式系统(Scalable Web Architecture and Distributed Systems)

    Open source software has become a fundamental building block for some of the biggest websites. And a ...

  8. Scalable Web Architecture and Distributed Systems

    转自:http://aosabook.org/en/distsys.html Scalable Web Architecture and Distributed Systems Kate Matsud ...

  9. 一段关于java NIO server端接受客户端socket连接;演示了关于channel,selector等组件的整合使用

    public class ReactorDemo { public static void main(String[] args) throws IOException { ServerSocketC ...

随机推荐

  1. fireBug使用指南

    据说,对于网页开发人员来说,Firebug是Firefox浏览器中最好的插件之一. 我最近就在学习怎么使用Firebug,网上找到一篇针对初学者的教程,感觉比较有用,就翻译了出来. ========= ...

  2. RN组件之ListView

    /** * Created by DaGuo on 2016/4/7. */ 'use strict' import React,{ Component, View, Text, ListView, ...

  3. Java虚拟机(JVM)中的内存设置详解

    在一些规模稍大的应用中,Java虚拟机(JVM)的内存设置尤为重要,想在项目中取得好的效率,GC(垃圾回收)的设置是第一步. PermGen space:全称是Permanent Generation ...

  4. iOS开发项目之三 [ 自定义tabBarCtrl]

    01 让tabBar的图片保持原样.图片渲染的处理 ctrl.tabBarItem.selectedImage = [[UIImage imageNamed:[NSString stringWithF ...

  5. FLTK 1.1.10 VS2010 Configuration 配置

    Download FLTK 1.1.10 at here. Download VS2010 Download CMake 2.8.12 I assume you've already installe ...

  6. php5全版本绕过open_basedir读文件脚本

    这是前段时间写的代码了(http://www.weibo.com/1074745063/ByAPqj7s0),最近一直忙着和几个同学一起做非安全类的创业项目.所以也没拿到JAE.SAE测试一下. 不说 ...

  7. 获取文本文件的第N行内容

    在PowerShell中,可以通过Get-Content这个cmdlet来获取文本文件的内容.Get-Content将一个文本文件读取到一个数组中,每一个数组元素就是文件的一行内容.比如一个文本文件内 ...

  8. Win2003+Powershell2.0下无权限解锁账号

    在GE环境下,我通过图形界面ADUC可以解锁一个员工账号,但是通过powershell命令却提示权限不足,咋回事?   PS C:\Users\814072> Unlock-ADAccount ...

  9. metasploit-post模块信息

    Name                                             Disclosure Date  Rank    Description ----           ...

  10. HDU 3555 数位dp入门

    开始想用dp[i][j]来记录第i位j开头含有49的数的个数 但是init后并不知道如何进行cal 想了想可以用不要62的思想 当作不要49来做 然后减一下 就好 看网上的代码 不要62和这道题用的d ...