netty4:How to listen on multiple ports on a java process

Question

I'm trying to listen for connections on two different ports

I start 2 Thread in a java main method,every Thread bind a port with netty4,but can't listener success! this is my code,the port 3333 is ok,but 1234 is not ok,it looks like 3333 is blocking!

    public class ObjectServer
    {
private static final Logger logger = LoggerFactory.getLogger(ObjectServer.class);

private String ip;
private int port;

public ObjectServer(int port)
{
    this.port = port;
}

public void run(final ChannelInboundHandlerAdapter handler) throws Exception
{
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try
    {
        ServerBootstrap server = new ServerBootstrap();
        server.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>()
        {
            @Override
            public void initChannel(SocketChannel ch) throws Exception
            {
                ch.pipeline().addLast(new ObjectEncoder(), new ObjectDecoder(ClassResolvers.cacheDisabled(null)), handler);
            }
        });
        server.bind(port).sync().channel().closeFuture().sync();
    }
    catch (Exception e)
    {
        logger.error("开启监听失败！端口[" + port + "]", e);
        throw e;
    }
    finally
    {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

}

 public class SocketServer
{
private static final Logger logger = LoggerFactory.getLogger(SocketServer.class);
private static final StringDecoder DECODER = new StringDecoder();
private static final StringEncoder ENCODER = new StringEncoder();
private int port;

public SocketServer(int port)
{
    this.port = port;
}

public void run(final ChannelInboundHandlerAdapter handler) throws Exception
{
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try
    {
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>()
        {
            @Override
            public void initChannel(SocketChannel ch) throws Exception
            {
                ChannelPipeline pipeline = ch.pipeline();
                // Add the text line codec combination first,
                pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
                // the encoder and decoder are static as these are
                // sharable
                pipeline.addLast("encoder", ENCODER);
                pipeline.addLast("decoder", DECODER);
                // and then business logic.
                pipeline.addLast("handler", handler);
            }
        });
        b.bind(port).sync().channel().closeFuture().sync();
    }
    catch (Exception e)
    {
        logger.error("开启监听失败！端口[" + port + "]", e);
        throw e;
    }
    finally
    {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

}

 public class Test
       {
    public static void main(String[] args) throws Exception
    {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread2.start();
        thread1.start();
        new SocketClient("192.168.16.52", 3333).run(new TestHandler4("test4"));
        new ObjectClient("192.168.16.52", 1234).run(new TestHandler3("test3"));
    }

    @Sharable
    static class TestHandler1 extends ChannelInboundHandlerAdapter
    {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
        {
            System.out.println("1234" + msg);
        }

    }

    static class Thread1 extends Thread
    {
        @Override
        public void run()
        {
            try
            {
                new ObjectServer(1234).run(new TestHandler1());
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    static class Thread2 extends Thread
    {
        @Override
        public void run()
        {
            try
            {
                new SocketServer(3333).run(new TestHandler2());
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    @Sharable
    static class TestHandler2 extends SimpleChannelInboundHandler<String>
    {
        @Override
        public void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception
        {
            System.out.println("3333" + msg);
        }

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception
        {
            System.out.println("sssssssssssssssss");
        }
    }

    @Sharable
    static class TestHandler3 extends ChannelInboundHandlerAdapter
    {
        private String msg;

        public TestHandler3(String msg)
        {
            this.msg = msg;
        }

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception
        {
            ctx.writeAndFlush(msg);
        }
    }

    @Sharable
    static class TestHandler4 extends SimpleChannelInboundHandler<String>
    {
        private String msg;

        public TestHandler4(String msg)
        {
            this.msg = msg;
        }

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception
        {
            ctx.writeAndFlush(msg);
        }

        @Override
        protected void channelRead0(ChannelHandlerContext arg0, String arg1)throws     Exception 
        {

        }
    }
}

Answer 1

In your run() implementation, you do this:

server.bind(port).sync().channel().closeFuture().sync();

.. which will block until the server socket is closed. Because you do not close the server socket, it will never return. Therefore, only the first server socket will be bound.

What you probably want is just bind and return rather than waiting for the server sockets closed.