如何实现nio监听两个端口，我server设置了7777 7778 为什么只能收到一个另一个收不到

求高手解决
客户端代码如下import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Set;

public class NIOClient {
    /*发送数据缓冲区*/
    private static ByteBuffer sBuffer = ByteBuffer.allocate(1024);
    /*接受数据缓冲区*/
    private static ByteBuffer rBuffer = ByteBuffer.allocate(1024);
    /*服务器端地址*/
    private InetSocketAddress SERVER;
    private static Selector selector;
    private static SocketChannel client;
    private static String receiveText;
    private static String sendText;
    private static int count=0;

    public NIOClient(int port){
        SERVER = new InetSocketAddress("localhost", port);
        init();
    }
    public void init(){
        try {
           /*
             * 客户端向服务器端发起建立连接请求
             */
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            selector = Selector.open();
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
            socketChannel.connect(SERVER);
            /*
             * 轮询监听客户端上注册事件的发生
             */
            while (true) {
                selector.select();
                Set<SelectionKey> keySet = selector.selectedKeys();
                for(final SelectionKey key : keySet){
                    handle(key);
                };
                keySet.clear();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        NIOClient client = new NIOClient(7777);
    }

    private void handle(SelectionKey selectionKey) throws IOException{
        if (selectionKey.isConnectable()) {
            /*
             * 连接建立事件，已成功连接至服务器
             */
            client = (SocketChannel) selectionKey.channel();
            if (client.isConnectionPending()) {
                client.finishConnect();
                System.out.println("connect success !");
                sBuffer.clear();
                sBuffer.put((new Date().toLocaleString()+" connected!").getBytes());
                sBuffer.flip();
                client.write(sBuffer);//发送信息至服务器
                /*
                 * 启动线程一直监听客户端输入，有信心输入则发往服务器端
                 * 因为输入流是阻塞的，所以单独线程监听
                 */
                new Thread(){
                    @Override
                    public void run() {
                        while(true){
                            try {
                                sBuffer.clear();
                                InputStreamReader input = new InputStreamReader(System.in);
                                BufferedReader br = new BufferedReader(input);
                                sendText = br.readLine();
                                /*
                                 * 未注册WRITE事件，因为大部分时间channel都是可以写的
                                 */
                                sBuffer.put(sendText.getBytes());
                                sBuffer.flip();
                                client.write(sBuffer);
                            } catch (IOException e) {
                                e.printStackTrace();
                                break;
                            }
                      }
                    };
                }.start();
            }
            //注册读事件
            client.register(selector, SelectionKey.OP_READ);
        } else if (selectionKey.isReadable()) {
            /*
             * 读事件触发
             * 有从服务器端发送过来的信息，读取输出到屏幕上后，继续注册读事件
             * 监听服务器端发送信息
             */
            client = (SocketChannel) selectionKey.channel();
            rBuffer.clear();
            count=client.read(rBuffer);
            if(count>0){
                receiveText = new String( rBuffer.array(),0,count);
                System.out.println(receiveText);
                client = (SocketChannel) selectionKey.channel();
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    }
}

server1.listen();//这里面while(true)，所以下面的代码得不到执行的机会
server.listen();

public static void main(String[] args) throws IOException {
        NIOSServer server1 = new NIOSServer(7778);
        NIOSServer server = new NIOSServer(7777);
         server1.listen();  //这里一直在while(true)。把NIOSServer 改成线程吧
        server.listen();
    }

NIOSServer实现Runnable接口
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
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.util.HashMap;
import java.util.Map;
import java.util.Set;
public class NIOSServer implements Runnable{
    private int port = 8888;
    private Charset cs = Charset.forName("gbk");
    private static ByteBuffer sBuffer = ByteBuffer.allocate(1024);
    private static ByteBuffer rBuffer = ByteBuffer.allocate(1024);
    private Map<String, SocketChannel> clientsMap = new HashMap<String, SocketChannel>();
    private static Selector selector;

    public NIOSServer(int port){
        this.port = port;
        try {
            init();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void init() throws IOException{
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        ServerSocket serverSocket = serverSocketChannel.socket();
        serverSocket.bind(new InetSocketAddress(port));
        selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("server start on port:"+port);
    }
//将listen()内的代码放到run()
    private void listen(){
    }

    @Override
public void run() {
// TODO Auto-generated method stub
while (true) {
            try {
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for(SelectionKey key : selectionKeys){
                    handle(key);
                }
                selectionKeys.clear();
            } catch (Exception e) {
                e.printStackTrace();
                break;
            }

        }
}
    private void handle(SelectionKey selectionKey) throws IOException, InterruptedException {
        ServerSocketChannel server = null;
        SocketChannel client = null;
        String receiveText=null;
        int count=0;
        if (selectionKey.isAcceptable()) {
            server = (ServerSocketChannel) selectionKey.channel();
            client = server.accept();
            //判断client 是否为空
            if(client != null){
             client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
            }
            Thread.sleep(10*1000);
        } else if (selectionKey.isReadable()) {
            client = (SocketChannel) selectionKey.channel();
            rBuffer.clear();
            count = client.read(rBuffer);
            if (count > 0) {
                rBuffer.flip();
                receiveText = String.valueOf(cs.decode(rBuffer).array());
                System.out.println(client.toString()+":"+receiveText);
                dispatch(client, receiveText);
                client = (SocketChannel) selectionKey.channel();
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    }

    private void dispatch(SocketChannel client,String info) throws IOException{
        Socket s = client.socket();
        String name = "["+s.getInetAddress().toString().substring(1)+":"+Integer.toHexString(client.hashCode())+"]";
        if(!clientsMap.isEmpty()){
            for(Map.Entry<String, SocketChannel> entry : clientsMap.entrySet()){
                SocketChannel temp = entry.getValue();
                if(!client.equals(temp)){
                    sBuffer.clear();
                    sBuffer.put((name+":"+info).getBytes());
                    sBuffer.flip();
                    temp.write(sBuffer);
                }
            }
        }
        clientsMap.put(name, client);
    }
    //删除main函数
}
NIOClient
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Set;
public class NIOClient {
    private static ByteBuffer sBuffer = ByteBuffer.allocate(1024);
    private static ByteBuffer rBuffer = ByteBuffer.allocate(1024);
    private InetSocketAddress SERVER;
    private static Selector selector;
    private static SocketChannel client;
    private static String receiveText;
    private static String sendText;
    private static int count=0;

    public NIOClient(int port){
        SERVER = new InetSocketAddress("localhost", port);
        init();
    }
    public void init(){
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            selector = Selector.open();
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
            socketChannel.connect(SERVER);
            while (true) {
                selector.select();
                Set<SelectionKey> keySet = selector.selectedKeys();
                for(final SelectionKey key : keySet){
                    handle(key);
                };
                keySet.clear();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException, InterruptedException {
     //创建NIOSServer
        NIOSServer server1 = new NIOSServer(7778);
        NIOSServer server = new NIOSServer(7777);
        new Thread(server1).start();
        new Thread(server).start();
        Thread.sleep(10*1000);
        //创建NIOSServer
     NIOClient client = new NIOClient(7777);
    }

    private void handle(SelectionKey selectionKey) throws IOException{
        if (selectionKey.isConnectable()) {
            client = (SocketChannel) selectionKey.channel();
            if (client.isConnectionPending()) {
                client.finishConnect();
                System.out.println("connect success !");
                sBuffer.clear();
                sBuffer.put((new Date().toLocaleString()+" connected!").getBytes());
                sBuffer.flip();
                client.write(sBuffer);
                new Thread(){
                    @Override
                    public void run() {
                        while(true){
                            try {
                                sBuffer.clear();
                                InputStreamReader input = new InputStreamReader(System.in);
                                BufferedReader br = new BufferedReader(input);
                                sendText = br.readLine();
                                sBuffer.put(sendText.getBytes());
                                sBuffer.flip();
                                client.write(sBuffer);
                            } catch (IOException e) {
                                e.printStackTrace();
                                break;
                            }
                      }
                    };
                }.start();
            }
            client.register(selector, SelectionKey.OP_READ);
        } else if (selectionKey.isReadable()) {
            client = (SocketChannel) selectionKey.channel();
            rBuffer.clear();
            count=client.read(rBuffer);
            if(count>0){
                receiveText = new String( rBuffer.array(),0,count);
                System.out.println(receiveText);
                client = (SocketChannel) selectionKey.channel();
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    }
}
执行NIOClient，输出
server start on port:7778
server start on port:7777
connect success !
java.nio.channels.SocketChannel[connected local=/127.0.0.1:7777 remote=/127.0.0.1:61140]:2014-4-8 14:19:41 connected!

可以把main方法写在server端吗，server端一直都是开启的

我把主方法写在里面了出现这个错误java.util.ConcurrentModificationException
at java.util.HashMap$HashIterator.nextEntry(Unknown Source)
at java.util.HashMap$KeyIterator.next(Unknown Source)
at test5.NIOSServer.run(NIOSServer.java:54)
at java.lang.Thread.run(Unknown Source)

main方法写在服务端还是只能接受一个客户端的信息  你看看我这样写错在什么地方
服务端main方法
  public static void main(String[] args) throws IOException {
NIOSServer server = new NIOSServer(7777);
NIOSServer server1 = new NIOSServer(7778);
new Thread(server1).start();
        new Thread(server).start();
        try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

只能接收一个客户端请求，是由于你在NIOSServer内将selector设置为static，注意static变量可以理解为类变量（与对象无关）。
当你执行NIOSServer server1 = new NIOSServer(7778); 时，创建了一个Selector，并将这个新创建的Selector赋值给static变量selector(selector = Selector.open();)，然后将监听7778端口的serverSocketChannel注册到selector。
当你执行NIOSServer server1 = new NIOSServer(7777)时，又创建了一个Selector，并将其赋值给static变量selector，然后将监听7778端口的serverSocketChannel注册到selector。
你执行NIOSServer server1 = new NIOSServer(7778);NIOSServer server1 = new NIOSServer(7777);，本想监听两个端口，其实只监听了7777端口
NIOClient内的selector也有同样的问题
先将NIOClient改为线程，然后删除NIOSServer 、NIOClient内的static关键字
NIOClient
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Set;
public class NIOClient implements Runnable{
    private ByteBuffer sBuffer = ByteBuffer.allocate(1024);
    private ByteBuffer rBuffer = ByteBuffer.allocate(1024);
    private InetSocketAddress SERVER;
    private Selector selector;
    private SocketChannel client;
    private String receiveText;
    private String sendText;
    private int count=0;

    public NIOClient(int port){
        SERVER = new InetSocketAddress("localhost", port);
        init();
    }
    public void init(){
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            selector = Selector.open();
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
            socketChannel.connect(SERVER);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void handle(SelectionKey selectionKey) throws IOException{
        if (selectionKey.isConnectable()) {
            client = (SocketChannel) selectionKey.channel();
            if (client.isConnectionPending()) {
                client.finishConnect();
                System.out.println("connect success !");
                sBuffer.clear();
                sBuffer.put((new Date().toLocaleString()+" connected!").getBytes());
                sBuffer.flip();
                client.write(sBuffer);
                new Thread(){
                    @Override
                    public void run() {
                        while(true){
                            try {
                                sBuffer.clear();
                                InputStreamReader input = new InputStreamReader(System.in);
                                BufferedReader br = new BufferedReader(input);
                                sendText = br.readLine();
                                sBuffer.put(sendText.getBytes());
                                sBuffer.flip();
                                client.write(sBuffer);
                            } catch (IOException e) {
                                e.printStackTrace();
                                break;
                            }
                      }
                    };
                }.start();
            }
            client.register(selector, SelectionKey.OP_READ);
        } else if (selectionKey.isReadable()) {
            client = (SocketChannel) selectionKey.channel();
            rBuffer.clear();
            count=client.read(rBuffer);
            if(count>0){
                receiveText = new String( rBuffer.array(),0,count);
                System.out.println(receiveText);
                client = (SocketChannel) selectionKey.channel();
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    }
@Override
public void run() {
// TODO Auto-generated method stub
try {
while (true) {
selector.select();
            Set<SelectionKey> keySet = selector.selectedKeys();
            for(final SelectionKey key : keySet){
                handle(key);
            };
            keySet.clear();
        }
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
NIOSServer
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
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.util.HashMap;
import java.util.Map;
import java.util.Set;
public class NIOSServer implements Runnable{
    private int port = 8888;
    private Charset cs = Charset.forName("gbk");
    private ByteBuffer sBuffer = ByteBuffer.allocate(1024);
    private ByteBuffer rBuffer = ByteBuffer.allocate(1024);
    private Map<String, SocketChannel> clientsMap = new HashMap<String, SocketChannel>();
    private Selector selector;

    public NIOSServer(int port){
        this.port = port;
        try {
            init();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void init() throws IOException{
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        ServerSocket serverSocket = serverSocketChannel.socket();
        serverSocket.bind(new InetSocketAddress(port));
        selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("server start on port:"+port);
    }      private void listen(){
    }

    @Override
public void run() {
// TODO Auto-generated method stub
while (true) {
            try {
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for(SelectionKey key : selectionKeys){
                    handle(key);
                }
                selectionKeys.clear();
            } catch (Exception e) {
                e.printStackTrace();
                break;
            }

        }
}
    private void handle(SelectionKey selectionKey) throws IOException, InterruptedException {
        ServerSocketChannel server = null;
        SocketChannel client = null;
        String receiveText=null;
        int count=0;
        if (selectionKey.isAcceptable()) {
            server = (ServerSocketChannel) selectionKey.channel();
            client = server.accept();
            //判断client 是否为空
            if(client != null){
             client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
            }
            Thread.sleep(10*1000);
        } else if (selectionKey.isReadable()) {
            client = (SocketChannel) selectionKey.channel();
            rBuffer.clear();
            count = client.read(rBuffer);
            if (count > 0) {
                rBuffer.flip();
                receiveText = String.valueOf(cs.decode(rBuffer).array());
                System.out.println(client.toString()+":"+receiveText);
                dispatch(client, receiveText);
                client = (SocketChannel) selectionKey.channel();
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    }

    private void dispatch(SocketChannel client,String info) throws IOException{
        Socket s = client.socket();
        String name = "["+s.getInetAddress().toString().substring(1)+":"+Integer.toHexString(client.hashCode())+"]";
        if(!clientsMap.isEmpty()){
            for(Map.Entry<String, SocketChannel> entry : clientsMap.entrySet()){
                SocketChannel temp = entry.getValue();
                if(!client.equals(temp)){
                    sBuffer.clear();
                    sBuffer.put((name+":"+info).getBytes());
                    sBuffer.flip();
                    temp.write(sBuffer);
                }
            }
        }
        clientsMap.put(name, client);
    }

    public static void main(String[] args) throws InterruptedException {
     //创建NIOSServer
     NIOSServer server1 = new NIOSServer(7778);
        NIOSServer server2 = new NIOSServer(7777);
        new Thread(server1).start();
        new Thread(server2).start();
        Thread.sleep(10*1000);
        //创建NIOClient
     NIOClient client1 = new NIOClient(7778);
     new Thread(client1).start();
     NIOClient client2 = new NIOClient(7777);
     new Thread(client2).start();
     NIOClient client3 = new NIOClient(7778);
     new Thread(client3).start();
     NIOClient client4 = new NIOClient(7777);
     new Thread(client4).start();
}
}
运行NIOSServer，输出
server start on port:7778
server start on port:7777
connect success !
connect success !
connect success !
connect success !
java.nio.channels.SocketChannel[connected local=/127.0.0.1:7778 remote=/127.0.0.1:52540]:2014-4-11 14:37:51 connected!
java.nio.channels.SocketChannel[connected local=/127.0.0.1:7777 remote=/127.0.0.1:52543]:2014-4-11 14:37:51 connected!
java.nio.channels.SocketChannel[connected local=/127.0.0.1:7778 remote=/127.0.0.1:52546]:2014-4-11 14:37:51 connected!
java.nio.channels.SocketChannel[connected local=/127.0.0.1:7777 remote=/127.0.0.1:52549]:2014-4-11 14:37:51 connected!
[127.0.0.1:5122152b]:2014-4-11 14:37:51 connected!
[127.0.0.1:149be3aa]:2014-4-11 14:37:51 connected!

调试易

如何实现nio监听两个端口，我server设置了7777 7778 为什么只能收到一个另一个收不到

解决方案 »