客户端服务器程序的多线程

客户端服务器程序的多线程

关注
发信
关注(28)粉丝(399)

客户端服务器程序的多线程

本文介绍了客户端服务器程序的多线程的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我试图实现多线程与我一直在努力的客户端/服务器程序。我需要允许多个客户端同时连接到服务器。我目前有4个类：一个客户端，一个服务器，一个协议和一个工人来处理线程。以下代码是我为这些类：



SocketServer类：

  public class SocketServer {
 
 
 public static void main（String [] args）throws IOException {
 
 int portNumber = 9987; 
 
 try（
 ServerSocket serverSocket = new ServerSocket（portNumber）; 
 Socket clientSocket = serverSocket.accept（）; 
 PrintWriter out = 
 new PrintWriter clientSocket.getOutputStream（），true）; 
 BufferedReader in = new BufferedReader（
 new InputStreamReader（clientSocket.getInputStream（）））; 
 
）{
 = new Thread（new ClientWorker（clientSocket））; 
 thread.start（）; // start thread 
 
 String inputLine，outputLine; 
 
 //启动与客户端的会话
协议prot = new Protocol（）; 
 outputLine = prot.processInput（null）; 
 out.println（outputLine）; 
 
 while（（inputLine = in.readLine（））！= null）{
 outputLine = prot.processInput（inputLine）; 
 out.println（outputLine）; 
 if（outputLine.equals（quit））
 break; 
} 
} catch（IOException e）{
 System.out.println（尝试在端口
 + portNumber +上侦听或侦听连接时捕获到异常 ）; 
 System.out.println（e.getMessage（））; 
} 
} 
}

SocketClient类别：

  public class SocketClient {
 public static void main（String [] args）throws IOException 
 {
 
 String hostName =localhost; 
 int portNumber = 9987; 
 
 try（
 Socket socket = new Socket（hostName，portNumber）; 
 PrintWriter out = new PrintWriter（socket.getOutputStream（），true）; 
 BufferedReader = new BufferedReader（
 new InputStreamReader（socket.getInputStream（）））; 
）{
 BufferedReader stdIn = 
 new BufferedReader（new InputStreamReader（System.in） 
 String fromServer; 
 String fromUser; 
 
 while（（fromServer = in.readLine（））！= null）{
 System.out.println（Server：+ fromServer）; 
 if（fromServer.equals（quit））
 break; 
 
 fromUser = stdIn.readLine（）; 
 if（fromUser！= null）{
 System.out.println（Client：+ fromUser）; 
 out.println（fromUser）; 
} 
} 
} catch（UnknownHostException e）{
 System.err.println（Do not know about host+ hostName）; 
 System.exit（1）; 
} catch（IOException e）{
 System.err.println（无法获得I / O的连接到+ 
 hostName）; 
 System.exit（1）; 
} 
} 
}

协议类别：

  public class Protocol {
 
 private static final int waiting = 0; 
 private static final int sentPrompt = 1; 
 
 
 private int status = waiting; 
 
 public String processInput（String theInput）{
 String theOutput = null; 
 
 if（status == waiting）{
 theOutput =请输入您想要检索的内容：'customer'或'product' 
 status = sentPrompt; 
} 
 else if（status == sentPrompt）{
 if（theInput.equalsIgnoreCase（product））{
 File f = new File（product.txt） ; 
 Scanner sc = null; 
 try {
 sc = new Scanner（f）; 
} catch（FileNotFoundException ex）{
 Logger.getLogger（Protocol.class.getName（））。log（Level.SEVERE，null，ex）; 
} 
 
 while（sc.hasNextLine（））{
 String line = sc.nextLine（）; 
 theOutput =当前产品条目是：+ line; 
} 
 return theOutput; 
} 
 else if（theInput.equalsIgnoreCase（customer））{
 File f = new File（customer.txt）; 
 Scanner sc = null; 
 try {
 sc = new Scanner（f）; 
} catch（FileNotFoundException ex）{
 Logger.getLogger（Protocol.class.getName（））。log（Level.SEVERE，null，ex）; 
} 
 
 while（sc.hasNextLine（））{
 String lines = sc.nextLine（）; 
 theOutput =当前客户条目是：+ line; 
} 
 return theOutput; 
 
} 
 else if（theInput.equalsIgnoreCase（quit））{
 returnquit; 
} 
 else {
 returnquit; 
} 
} 
 return theOutput; 
} 
}

ClientWorker类：​​

  public class ClientWorker implements Runnable {
 private final Socket client; 
 
 public ClientWorker（Socket客户端）{
 this.client = client; 
} 
 
 @Override 
 public void run（）{
 String line; 
 BufferedReader in = null; 
 PrintWriter out = null; 
 try {
 System.out.println（Thread started with name：+ Thread.currentThread（）。getName（））; 
 in = new BufferedReader（new InputStreamReader（client.getInputStream（）））; 
 out = new PrintWriter（client.getOutputStream（），true）; 
} catch（IOException e）{
 System.out.println（in或out failed）; 
 System.exit（-1）; 
} 
 
 while（true）{
 try {
 System.out.println（Thread running with name：+ Thread.currentThread（）。getName ））; 
 line = in.readLine（）; 
 //将数据发送回客户端
 out.println（line）; 
 //将数据附加到文本区
} catch（IOException e）{
 System.out.println（Read failed）; 
 System.exit（-1）; 
} 
} 
} 
}

我运行服务器和客户端，一切工作正常如预期。然后当我尝试运行另一个客户端，它只是挂在那里，并不提示客户端给出响应。

解决方案

您的服务器代码应该实现以下功能。


  1. 继续接受


  2. 通过传递客户端套接字（即） p>


  3. 在客户端套接字线程中执行IO处理，例如 ClientWorker

请查看此



您的代码应为

  ServerSocket serverSocket = new ServerSocket（portNumber）; 
 while（true）{
 try {
 Socket clientSocket = serverSocket.accept（）; 
线程线程= new ClientWorker（clientSocket）; 
 thread.start（）; // start thread 
} catch（Exception err）{
 err.printStackTrace（）; 
} 
}


I am trying to implement multi threading with a client/server program I have been working on. I need to allow multiple clients to connect to the server at the same time. I currently have 4 classes: a Client, a Server, a Protocol and a Worker to handle the threads. The following code is what I have for those classes:

SocketServer Class:

public class SocketServer {


     public static void main(String[] args) throws IOException {

        int portNumber = 9987;

        try (
            ServerSocket serverSocket = new ServerSocket(portNumber);
            Socket clientSocket = serverSocket.accept();
            PrintWriter out =
                new PrintWriter(clientSocket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));

        ) {
            Thread thread = new Thread(new ClientWorker(clientSocket));
            thread.start(); //start thread

            String inputLine, outputLine;

            // Initiate conversation with client
            Protocol prot = new Protocol();
            outputLine = prot.processInput(null);
            out.println(outputLine);

            while ((inputLine = in.readLine()) != null) {
                outputLine = prot.processInput(inputLine);
                out.println(outputLine);
                if (outputLine.equals("quit"))
                    break;
            }
        } catch (IOException e) {
            System.out.println("Exception caught when trying to listen on port "
                + portNumber + " or listening for a connection");
            System.out.println(e.getMessage());
        }
    }
}

SocketClient Class:

public class SocketClient {
     public static void main(String[] args) throws IOException
    {

        String hostName = "localhost";
        int portNumber = 9987;

        try (
            Socket socket = new Socket(hostName, portNumber);
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
        ) {
            BufferedReader stdIn =
            new BufferedReader(new InputStreamReader(System.in));
            String fromServer;
            String fromUser;

            while ((fromServer = in.readLine()) != null) {
                System.out.println("Server: " + fromServer);
                if (fromServer.equals("quit"))
                    break;

                fromUser = stdIn.readLine();
                if (fromUser != null) {
                    System.out.println("Client: " + fromUser);
                    out.println(fromUser);
                }
            }
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host " + hostName);
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for the connection to " +
                hostName);
            System.exit(1);
        }
    }
}

Protocol Class:

public class Protocol {

    private static final int waiting         = 0;
    private static final int sentPrompt      = 1;


    private int status = waiting;

     public String processInput(String theInput) {
         String theOutput = null;

        if (status == waiting) {
            theOutput = "Please enter what you would like to retrieve: 'customer' or 'product' ";
            status = sentPrompt;
        }
        else if ( status == sentPrompt ) {
            if ( theInput.equalsIgnoreCase("product")) {
                File f = new File("product.txt");
                Scanner sc = null;
                try {
                    sc = new Scanner(f);
                } catch (FileNotFoundException ex) {
                    Logger.getLogger(Protocol.class.getName()).log(Level.SEVERE, null, ex);
                }

                while ( sc.hasNextLine()  ) {
                    String line   = sc.nextLine();
                    theOutput = "The current product entries are : " + line;
                }
                return theOutput;
            }
            else if ( theInput.equalsIgnoreCase("customer")) {
                File f = new File("customer.txt");
                Scanner sc = null;
                try {
                    sc = new Scanner(f);
                } catch (FileNotFoundException ex) {
                    Logger.getLogger(Protocol.class.getName()).log(Level.SEVERE, null, ex);
                }

                while ( sc.hasNextLine()  ) {
                    String line   = sc.nextLine();
                    theOutput = "The current customer entries are : " + line;
                }
                return theOutput;

            }
            else if ( theInput.equalsIgnoreCase("quit")) {
                return "quit";
            }
            else {
                return "quit";
            }
        }
        return theOutput;
    }
}

The ClientWorker Class:

public class ClientWorker implements Runnable {
    private final Socket client;

    public ClientWorker( Socket client ) {
        this.client = client;
    }

    @Override
    public void run() {
        String line;
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            System.out.println("Thread started with name:"+Thread.currentThread().getName());
            in = new BufferedReader(new InputStreamReader(client.getInputStream()));
            out = new PrintWriter(client.getOutputStream(), true);
        } catch (IOException e) {
            System.out.println("in or out failed");
            System.exit(-1);
        }

        while (true) {
            try {
                System.out.println("Thread running with name:"+Thread.currentThread().getName());
                line = in.readLine();
                //Send data back to client
                out.println(line);
                //Append data to text area
            } catch (IOException e) {
                System.out.println("Read failed");
                System.exit(-1);
            }
        }
    }
}

When I run the server and client, everything works fine as expected. Then when I try to run another client, it just hangs there and does not prompt the client to give a response. Any insight into what I am missing is greatly appreciated!

解决方案

Your server code should address implement below functionalities.

  1. Keep accepting socket from ServerSocket in a while loop

  2. Create new thread after accept() call by passing client socket i.e Socket

  3. Do IO processing in client socket thread e.g ClientWorker in your case.

Have a look at this article

Your code should be 

ServerSocket serverSocket = new ServerSocket(portNumber);
while(true){
  try{
    Socket clientSocket = serverSocket.accept();
    Thread thread = new ClientWorker(clientSocket);
    thread.start(); //start thread
  }catch(Exception err){
     err.printStackTrace();
  }
}

这篇关于客户端服务器程序的多线程的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！

08-03 21:55
Powered by LMLPHP ©2024 客户端服务器程序的多线程 0.045173