Netty客户端相对于I / O客户端的好处？

Question

I want to know if I can save my application threads by implementing Netty Client.

I wrote a demo client please find the below code. Expecting that a single thread can connect to different port handle them efficiently but i was wrong. Netty creates per thread connection.

public class NettyClient {
    public static void main(String[] args) {
    Runnable runA = new Runnable() {
        public void run() {
            Connect(5544);
        }
    };

    Thread threadA = new Thread(runA, "threadA");
    threadA.start();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException x) {
    }

    Runnable runB = new Runnable() {
        public void run() {
            Connect(5544);
        }
    };

    Thread threadB = new Thread(runB, "threadB");
    threadB.start();

}

static ClientBootstrap bootstrap = null;
static NettyClient ins = new NettyClient();
public NettyClient() {

    bootstrap = new ClientBootstrap(new NioClientSocketChannelFactory(
            Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
    /*
     * ClientBootstrap A helper class which creates a new client-side
     * Channel and makes a connection attempt.
     * 
     * NioClientSocketChannelFactory A ClientSocketChannelFactory which
     * creates a client-side NIO-based SocketChannel. It utilizes the
     * non-blocking I/O mode which was introduced with NIO to serve many
     * number of concurrent connections efficiently
     * 
     * There are two types of threads :Boss thread Worker threads Boss
     * Thread passes control to worker thread.
     */
    // Configure the client.

    ChannelGroup channelGroup = new DefaultChannelGroup(NettyClient.class.getName());
    // Only 1 thread configured but still aceepts threadA and Thread B
    // connection
    OrderedMemoryAwareThreadPoolExecutor pipelineExecutor = new OrderedMemoryAwareThreadPoolExecutor(
            1, 1048576, 1073741824, 1, TimeUnit.MILLISECONDS,
            new NioDataSizeEstimator(), new NioThreadFactory("NioPipeline"));

    bootstrap.setPipelineFactory(new NioCommPipelineFactory(channelGroup,
            pipelineExecutor));

    // bootstrap.setPipelineFactory(new
    // BackfillClientSocketChannelFactory());
    bootstrap.setOption("child.tcpNoDelay", true);

    bootstrap.setOption("child.keepAlive", true);
    bootstrap.setOption("child.reuseAddress", true);
    bootstrap.setOption("readWriteFair", true);
}

public static NettyClient getins() {
    return ins;
}

public static void Connect(int port) {
    ChannelFuture future = bootstrap
            .connect(new InetSocketAddress("localhost", port));

    Channel channel = future.awaitUninterruptibly().getChannel();
    System.out.println(channel.getId());
    channel.getCloseFuture().awaitUninterruptibly();
}

}

Now I want to know what are the benefits of using Netty client? Does it save Threads?

Answer 1

Netty saves threads. Your NettyClient wastes threads when waiting synchronously for opening and closing of the connections (calling awaitUninterruptibly()).

BTW how many connections will your client have? Maybe using classic synchronous one-thread-per-connection approach would suffice? Usually we have to save threads on a server side.

Answer 2

Netty allows you to handle thousands of connections with a handful of threads . When used in a client application, it allows a handful of threads to make thousands of concurrent connections to server.

You have put sleep() in your thread. We must never block the Netty worker/boss threads. Even if there is a need to perform any one-off blocking operation, it must be off-loaded to another executor. Netty uses NIO, and the same thread can be used for creating a new connection, while the earlier connection gets some data in its input buffer.