NodeJS vs Netty

虚幻0516

　　周末跟朋友聊天, 一个朋友说NodeJS是个不错的东西, 它的非阻塞异步处理模式比用apache的fork的方式高效.
　　我在想如果是依靠非阻塞异步处理的方式提升性能的话, 其实现在主流的平台上都有相应的东西, 例如Java的NIO. 我想肯定有人做过比较, 于是我上网搜了一下Node.js vs Netty.
　　用apache benchmark来做的基于HTTP协议上的Helloworld的测试

ab -r30000 -c100 http://localhost:<port>/
　　这个benchmark测试下来的结果是Netty的wormup时间比Node.js长, 但整体来说性能要高40%. 这个测试结果本身并不能说明什么问题. 因为Helloworld和实际应用相差太远.
　　Node.js 实现代码

var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World\n');
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');
　　Netty 实现代码
　　NettyModule.java

public class NettyModule extends AbstractModule {
@Override
protected void configure() {
}
@Provides
SocketAddress provideSocketAddress() {
return new InetSocketAddress(8080);
}
@Provides @Singleton
ChannelGroup provideChannelGroup() {
return new DefaultChannelGroup("http-server");
}
@Provides
ChannelFactory provideChannelFactory() {
return new NioServerSocketChannelFactory(
Executors.newCachedThreadPool(), Executors.newCachedThreadPool());
}
public static void main(String[] args) {
Injector injector = Guice.createInjector(new NettyModule());
final NettyServer server = injector.getInstance(NettyServer.class);
server.startAndWait();
Runtime.getRuntime().addShutdownHook(new Thread(){
@Override
public void run() {
server.stopAndWait();
}
});
}
}
　　NettyServer.java

package netty;
import java.net.SocketAddress;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.buffer.ChannelBuffers;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelFactory;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.ChannelFutureListener;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.group.ChannelGroup;
import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
import org.jboss.netty.handler.codec.http.HttpResponse;
import org.jboss.netty.handler.codec.http.HttpResponseStatus;
import org.jboss.netty.handler.codec.http.HttpServerCodec;
import org.jboss.netty.handler.codec.http.HttpVersion;
import com.google.common.base.Charsets;
import com.google.common.util.concurrent.AbstractIdleService;
import com.google.inject.Inject;
import com.google.inject.Provider;
class NettyServer extends AbstractIdleService {
private final ChannelGroup allChannels;
private final SocketAddress address;
private final ChannelFactory factory;
private final ServerBootstrap bootstrap;
private final Provider<Handler> handler;
@Inject
NettyServer(ChannelFactory factory, ChannelGroup allChannels, SocketAddress address, Provider<Handler> handler) {
this.factory = factory;
this.bootstrap = new ServerBootstrap(factory);
this.allChannels = allChannels;
this.address = address;
this.handler = handler;
}
@Override
protected void startUp() throws Exception {
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() throws Exception {
return Channels.pipeline(new HttpServerCodec(), handler.get());
}
});
bootstrap.setOption("child.tcpNoDelay", true);
bootstrap.setOption("child.keepAlive", true);
Channel channel = bootstrap.bind(address);
allChannels.add(channel);
}
@Override
protected void shutDown() throws Exception {
allChannels.close().awaitUninterruptibly();
factory.releaseExternalResources();
}
}
class Handler extends SimpleChannelHandler {
private final ChannelGroup allChannels;
@Inject
Handler(ChannelGroup allChannels) {
this.allChannels = allChannels;
}
@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
allChannels.add(e.getChannel());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
throws Exception {
e.getCause().printStackTrace();
e.getChannel().close();
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
throws Exception {
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
response.setContent(ChannelBuffers.copiedBuffer("Hello, world!", Charsets.UTF_8));
e.getChannel().write(response).addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
future.getChannel().close();
}});
}
}
　　原文地址:http://devnest.blogspot.hk/2012/01/nodejs-vs-netty.html
　　我觉得原文的回复最有意思

Typical php-codemonkey would simply stop reading after the first snippet, silently committing to 40% worse performance - 6 loc vs 100+ loc... :-)
　　一般来说PHP的程序员在读完第一个代码片段后就不会再往下读了, 宁愿忍受40%的性能差距. 6行代码VS 100+代码!