这段代码有什么问题……？ Java插座编程

Question

I am coding client-server multithread calculator using java, socket programming. There's any syntax error, but msgs cannot be received from server.

I think

receiveString = inFromServer.readLine()

does not works. This code is in Client program, in the while(true) loop.

What is the problem? Here is my full code.

SERVER

import java.io.*;
import java.net.*;

public class Server implements Runnable 
{
    static int max = 5; //maximum thread's number
    static int i = 0, count = 0; //i for for-loop, count for count number of threads

    public static void main(String args[]) throws IOException 
    {
        ServerSocket serverSocket = new ServerSocket(6789); //open new socket
        File file = new File("src/serverinfo.dat"); //make data file to save server info.
        System.out.println("Maximum 5 users can be supported.\nWaiting...");

        for(i=0; i <= max; i++) { new Connection(serverSocket); } //make sockets - loop for max(=5) times

        try //server information file writing
        { 
            String dataString = "Max thread = 5\nServer IP = 127.0.0.1\nServer socket = 6789\n";
            @SuppressWarnings("resource")
            FileWriter dataFile = new FileWriter(file);
            dataFile.write(dataString);
        }
        catch(FileNotFoundException e) { e.printStackTrace(); }
        catch(IOException e) { e.printStackTrace(); }
    }


    static class Connection extends Thread
    {
        private ServerSocket serverSocket;

        public Connection(ServerSocket serverSock)
        {
            this.serverSocket = serverSock;
            start();
        }

        public void run()
        { 
            Socket acceptSocket = null;
            BufferedReader inFromClient = null;
            DataOutputStream msgToClient = null;
            String receiveString = null;
            String result = "", sys_msg = "";

            try
            {
                while(true)
                {
                    acceptSocket = serverSocket.accept(); // 접속수락 소켓
                    count++;

                    inFromClient = new BufferedReader(new InputStreamReader(acceptSocket.getInputStream()));
                    msgToClient = new DataOutputStream(acceptSocket.getOutputStream());
                    System.out.println(count + "th client connected: " + acceptSocket.getInetAddress().getHostName() + "    " + count + "/" + max);
                    System.out.println("Waiting response...");

                    while(true)
                    {

                        if (count >= max+1) // if 6th client tries to access
                        {
                            System.out.println("Server is too busy. " + max + " clients are already connected. Client access denied.");
                            sys_msg = "DENIED";
                            msgToClient.writeBytes(sys_msg);
                            acceptSocket.close();
                            count--;
                            break;
                        }

                        try{ msgToClient.writeBytes(result); }
                        catch(Exception e) {}

                        try{ receiveString = inFromClient.readLine(); }
                        catch(Exception e) // if receiveString = null
                        {
                            System.out.println("Connection Close");
                            count--;
                            break;
                        }

                        System.out.println("Input from client : " + receiveString);

                        try
                        {       

                            if(receiveString.indexOf("+") != -1) { result = cal("+", receiveString); }
                            else if(receiveString.indexOf("-") != -1) { result = cal("-", receiveString); }
                            else if(receiveString.indexOf("/") != -1) { result = cal("/", receiveString); }
                            else if(receiveString.indexOf("*") != -1) { result = cal("*", receiveString); }
                            else if(receiveString.indexOf("+") == -1 || receiveString.indexOf("-") == -1 || receiveString.indexOf("*") == -1 || receiveString.indexOf("/") == -1) { result = "No INPUT or Invalid operation"; }
                        }
                        catch(Exception e){ result = "Wrong INPUT"; }

                        try{ msgToClient.writeBytes(result); }
                        catch(Exception e) {}
                    }
                }
            }
            catch(IOException e) { e.printStackTrace(); }
        }
    }

    private static String cal(String op, String recv) //function for calculating
    {
        double digit1, digit2; //first number, second number

        String result = null;

        digit1 = Integer.parseInt(recv.substring(0, recv.indexOf(op)).trim());
        digit2 = Integer.parseInt(recv.substring(recv.indexOf(op)+1, recv.length()).trim());

        if(op.equals("+")) { result = digit1 + " + " + digit2 + " = " + (digit1 + digit2); }
        else if(op.equals("-")) { result = digit1 + " - " + digit2 + " = " + (digit1 - digit2); }
        else if(op.equals("*")) { result = digit1 + " * " + digit2 + " = " + (digit1 * digit2); }
        else if(op.equals("/"))
        {
            if(digit2 == 0){ result = "ERROR OCCURRED: Cannot be divided by ZERO"; }
            else{ result = digit1 + " / " + digit2 + " = " + (digit1 / digit2); }
        }
        return result;
    }

    @Override
    public void run() {
  //    TODO Auto-generated method stub
    }
}

-----------------------------------------------------------------
CLIENT

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String args[]) throws IOException
    {
        Socket clientSocket = null;

        BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
        BufferedReader inFromServer = null;
        DataOutputStream msgToServer = null;

        String sendString = "", receiveString = "";

        try
        {
            clientSocket = new Socket("127.0.0.1", 6789); //make new clientSocket
            inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            msgToServer = new DataOutputStream(clientSocket.getOutputStream());

            System.out.println("Input exit to terminate");
            System.out.println("Connection Success... Waiting for permission");

            while(true)
            {
                receiveString = inFromServer.readLine();
                if(receiveString.equals("DENIED"))
                {
                    System.out.println("Server is full. Try again later.");
                    break;
                }
                else { System.out.println("Connection permitted."); }

                System.out.print("Input an expression to calculate(ex. 3+1): ");
                sendString = userInput.readLine();

                if(sendString.equalsIgnoreCase("exit")) //when user input is "exit" -> terminate
                {
                    clientSocket.close();
                    System.out.println("Program terminated.");
                    break;
                }

                try { msgToServer.writeBytes(sendString); }
                catch(Exception e) {}

                try { receiveString = userInput.readLine(); }
                catch(Exception e) {}

                System.out.println("Result: " + receiveString); //print result
            }
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

Answer 1

You've set up your server socket stack wrong.

Your code will make 5 threads, each calling accept on a serversocket.

The idea is to have a single ServerSocket (and not 5, as in your example). Then, this single serversocket (running in a single thread that handles incoming sockets flowing out of this serversocket) will call .accept which will block (freeze the thread) until a connection is made, and will then return a Socket object. You'd then spin off a thread to handle the socket object, and go right back to the accept call. If you want to 'pool' (which is not a bad idea), then disassociate the notion of 'handles connections' from 'extends Thread'. For example, implement Runnable instead. Then pre-create the entire pool (for example, 10 threads), have some code that lets you 'grab a thread' from the pool and 'return a thread' to the pool, and now the serversocket thread will, upon accept returning a socket object, grab a thread from the pool (which will block, thus also blocking any incoming clients, if every thread in the pool is already taken out and busy handling a connection), until a thread returns to the pool. Alternatively, the serversocket code checks if the pool is completely drained and if so, will put on a final thread the job of responding to that client 'no can do, we are full right now'.

I'm not sure if you actually want that; just.. make 1 thread per incoming socket is a lot simpler. I wouldn't dive into pool concepts until you really need them, and if you do, I'd look for libraries that help manage them. I think further advice on that goes beyond the scope of this question, so I'll leave the first paragraph as an outlay of how ServerSocket code ought to work, for context.