试图在java应用程序中为单个端口创建多个套接字（连接），但无法创建新的套接字

在下面的代码中，当我在newSocket=serverSocket.accept（）返回while语句（在下面的BOLD文本中突出显示）时，我建立了第一个没有问题的连接；行，我的程序到此为止。目标是允许多个连接到一个端口。我正在重构一个继承的应用程序，该应用程序一直在工作，但每次只允许一个端口连接一个端口。这是我第一次尝试socket编程，如有任何建议/指导，将不胜感激。谢谢

以下是我正在使用的代码：

public void connect() {     

    LOGGER.info("Connecting ... ");
    while (!shouldTerminate) {

        ActiveSocket activeSocket = null;
        Socket newSocket = null;
        int tries = 0;
        int loopCounter = 0;

        if (isServer) {
            if (host == null) {
                LOGGER.info("Must specify a host ip or host name with HOST configuration tag ");
                return;
            } else {
                // keep accepting new socket connections until you have max active sockets
                while (!shouldTerminate && (activeSockets.size() < this.maxActiveSockets)) {
                    activeSocket = new ActiveSocket();
                    newSocket = null;       
                    if (serverSocket != null) {                         
                        try {
                            LOGGER.info("Accept socket ");
                            String ipAddrValue = serverSocket.getInetAddress().toString();  
                            String hostValue = host;
                            int portValue = serverSocket.getLocalPort();
                            **newSocket = serverSocket.accept();**
                        } catch (final IOException ex) {
                            if (shouldTerminate) {
                                if (ex.getMessage() != null) {
                                    LOGGER.info(ex.getMessage());
                                }
                            } else {
                                LOGGER.info("IOException while accepting connection ");
                                LOGGER.warn(FormatData.fullStackTrace(ex));
                            }
                            newSocket = null;
                        }
                        if (newSocket != null) {
                            try {
                                LOGGER.info("Socket keepalive ... ");
                                newSocket.setKeepAlive(true);                                   
                                activeSocket.setSocket(newSocket);
                                increaseConnects();
                            } catch (final SocketException ex) {
                                LOGGER.info("SocketException while opening socket ");
                                LOGGER.warn(FormatData.fullStackTrace(ex));
                                newSocket = null;
                            }
                        }
                    } else { // first time through the loop
                        try {
                            LOGGER.info("Opening server socket (" + host + "," + port + ") for BankID:" + Integer.toString(this.getBankID()));
                            serverSocket = new ServerSocket(port);
                        } catch (final IOException ex) {
                            LOGGER.info("Unable to open server socket socket (" + host + "," + port + ")");
                            if (ex.getMessage().indexOf("Cannot assign requested address") > -1) {
                                this.terminate();
                                final String logMessage = "Invalid IP Address assigned:" + host + ",port:" + port;
                                final String subject = logMessage;
                                ATMServer.sendNotification(subject, logMessage);
                            } else if (tries == 0) {
                                tries++;
                                final String logMessage = "Unable to open server socket (" + host + "," + port + ")";
                                final String subject = "Unable to open server socket (" + host + "," + port + ")";
                                ATMServer.sendNotification(subject, logMessage);
                            }
                            LOGGER.warn(FormatData.fullStackTrace(ex));
                        }
                    }
                }
            }
        } else { // client socket -- connecting to a bank
            LOGGER.info("Not server and terminal type is null ");
            while (!shouldTerminate && (activeSockets.size() < this.maxActiveSockets)) {
                activeSocket = new ActiveSocket();
                newSocket = null;
                if (this.isInForcedStandIn()) {
                    LOGGER.info("Forced standin " + getName());
                    try {
                        Thread.sleep(3000); // @TODO switch to a
                                            // notification when not in
                                            // standin
                    } catch (final InterruptedException ex) {
                        LOGGER.info("Interrupted while waiting for connection ");
                        LOGGER.warn(FormatData.fullStackTrace(ex));
                    }
                } else {
                    if (!shouldTerminate) {
                        if ((loopCounter % 120) == 0) {
                            try {
                                LOGGER.info("Connecting to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
                                newSocket = new Socket(InetAddress.getByName(remoteHost), remotePort);
                                if (newSocket.isConnected()) {
                                    tries = 0;
                                    LOGGER.info("socket connected to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
                                }

                                newSocket.setKeepAlive(true);
                                if (newSocket.getKeepAlive()) {
                                    LOGGER.info("socket keep alive to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
                                }
                                activeSocket.setSocket(newSocket);
                                increaseConnects();
                            } catch (final IOException ex) {
                                loopCounter++;
                                tries++;
                                LOGGER.info("SocketException while opening remote socket (" + remoteHost + "," + remotePort + ") " + " " + ex.getClass() + " " + ex.getMessage());

                                if ((tries % 300) == 0) {
                                    recordErrorToDatabase(ex.getMessage());
                                }
                            }
                        } else {
                            loopCounter++;
                            try {
                                synchronized (clientConnectLock) {
                                    clientConnectLock.wait(1000);
                                }
                            } catch (final InterruptedException inex) {
                                LOGGER.info("SocketException while opening remote socket " + Thread.currentThread().getName());
                                LOGGER.warn(FormatData.fullStackTrace(inex));
                                if (!this.shouldTerminate) {
                                    recordErrorToDatabase("InterruptedException without terminate set.");
                                }
                            }
                        }
                    }
                }
            }
        }
        try {
            // here, if we created a new ActiveSocket, establish dataInput and dataOuput streams
            // then add to the list of active streams.
            // for Discover, this will mean adding up to MaxActiveSockets # of sockets
            // to the activeSockets list.
            // for each other SwitchChannel, this will be the only activeSocket
            if (activeSocket != null) {
                LOGGER.info("Creating serverIn/serverOut data streams " + Thread.currentThread().getName());
                DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(newSocket.getInputStream()));
                if (newSocket.isConnected()) {
                    LOGGER.info("socket still connected to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
                }
                DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(newSocket.getOutputStream(), 2048));
                activeSocket.setDataInputStream(dataInputStream);
                activeSocket.setDataOutputStream(dataOutputStream);
                activeSockets.add(activeSocket);
                activeSocket.setNumReceivers(this.numReceivers);
                ReceiveQueuer[] receiveQueuers = activeSocket.getReceiveQueuers();
                LOGGER.info("Starting receive queuers");
                for (int cnt = 0; cnt < numReceivers; cnt++) {
                    receiveQueuers[cnt].setName(this.systemName + "-Socket-" + Integer.toString(activeSockets.size()) + "-ReceiveQueuer-" + Integer.toString(cnt));
                    receiveQueuers[cnt].setActiveSocket(activeSocket);
                    receiveQueuers[cnt].start();
                }
            }
        } catch (final Exception ex) {
            LOGGER.info("Exception while creating input/output streams " + Thread.currentThread().getName());
            LOGGER.warn(FormatData.fullStackTrace(ex));
        }
    }
    if (!shouldTerminate) {
        LOGGER.info("Socket connection complete " + Thread.currentThread().getName());
    } else {
        LOGGER.info("Stopped establishing socket connection " + Thread.currentThread().getName());
    }

public void connect（）{
LOGGER.info（“连接…”）；
而（！shouldTerminate）{
ActiveSocket-ActiveSocket=null；
套接字newSocket=null；
int=0；
int循环计数器=0；
如果（isServer）{
if（主机==null）{
LOGGER.info（“必须使用主机配置标签指定主机ip或主机名”）；
返回；
}否则{
//继续接受新的套接字连接，直到有最大活动套接字
而（！shouldTerminate&（activeSockets.size（）-1）{
这个。终止（）；
最后一个字符串logMessage=“分配的IP地址无效：“+host+”，端口：“+port；
最终字符串主题=日志消息；
发送通知（主题、日志消息）；
}else if（尝试==0）{
尝试++；
最终字符串logMessage=“无法打开服务器套接字（“+host+”，“+port+”）；
最后一个字符串subject=“无法打开服务器套接字（“+host+”，“+port+”）；
发送通知（主题、日志消息）；
}
LOGGER.warn（FormatData.fullStackTrace（ex））；
}
}
}
}
}else{//客户端套接字--连接到银行
LOGGER.info（“非服务器，终端类型为空”）；
而（！shouldTerminate&（activeSockets.size（）