Wo die Zeile "serverSocket.accept();" in einem multithreaded Java-Programm

Question

Ich versuche, ein Programm, in dem der Server und Client erstellen können Nachrichten an/voneinander senden und empfangen zur gleichen Zeit (die gleiche Art und Weise zwei Menschen mit Handys sie Text können)

Es gibt drei Dateien (die Hauptfunktionsdatei, die Serverdatei, die Clientdatei) Ich möchte mich nur auf die Server- und Hauptdatei konzentrieren.

Das Problem mit der Server-Datei ist, dass es zwei separate Threads gibt, in denen jeder Thread seine eigene "run" -Funktion hat, also frage ich mich, wo ich die "socket.accept()" Zeile setzen sollte, um beides zu machen von ihnen arbeiten (vielleicht vor, global irgendwie?)

die Argumente Befehlszeile den Server auszuführen

java DirectMessengerCombined -l 3000 

wenn „-l“ sind nicht vorhanden ist, dann wird es als Client

laufen

Der Ablauf der Server-Datei denke ich würde etwas gehen ike diese (Pseudocode Kommentare) (korrigiert mich wenn ich falsch liege)

//Server listens for connections 
//then accepts the connection from client 
//Recieving msesages: 
     //function recieves messages, create and run a functon that recieves messages 
     //read from the socket until the other side closes 
     //display the recieved message 


//Sending: Standard input begins 
     //create and run a functon that sends messages 
     //write using standard input as long as the user doesn't close it, in a loop 


//user close standard input to end the program 

Nach dieser Strömung wäre es möglich, eine Verbindung außerhalb des ersten run-Methode aus dem Thread zu akzeptieren? Vielleicht im Konstruktor?

Server-Code:

import java.io.*; 
import java.net.*; 
import java.util.*; 
import javax.imageio.IIOException; 
public class DirectMessengerServer 
{ 

    private String[] serverArgs; 
    private static Socket socket; 
    public boolean keepRunning = true; 

    public DirectMessengerServer(String[] args) throws IOException 
    { 

     // should serverSocket.accept() go here??? 



     // set the instance variable 
     this.serverArgs = args; 
     int port_number1 = Integer.valueOf(serverArgs[1]); 
     ServerSocket serverSocket = new ServerSocket(port_number1); 
     socket = serverSocket.accept(); 
    } 

     public String[] ServerRun(String[] args) 
     { 
     serverArgs = args; 
     serverArgs = Arrays.copyOf(args, args.length); 
     return serverArgs; 
     } 


     // should serverSocket.accept() go here??? 

    Thread ServerRecieve = new Thread(); 


//If i put serverSocket.accept() in both the run methods, won't that cause an "Address already in use error"? 

//run method of ServerRecieve 
public void run(String args[]) 
{ 
    System.out.println("Server recieve thread is now running"); 
    try 
    { 


     while(keepRunning) 
     { 
      //Reading the message from the client 


      InputStream is = socket.getInputStream(); 
      InputStreamReader isr = new InputStreamReader(is); 
      BufferedReader br = new BufferedReader(isr); 
      String MessageFromClient = br.readLine(); 
      System.out.println("Message received from client: "+ MessageFromClient); 


     } 
    } 
    catch (IOException e) 
    { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    finally 
    { 
     try 
     { 
      socket.close(); 
     } 
     catch (IOException e) 
     { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 
} 

Thread ServerSend = new Thread(); 

//Run method of ServerSend 
public void run() 
{ 
    while(keepRunning) 
    { 
     System.out.println("Server sending thread is now running"); 
     try 
     {   

      //Send the message to the server 
      OutputStream os = socket.getOutputStream(); 
      OutputStreamWriter osw = new OutputStreamWriter(os); 
      BufferedWriter bw = new BufferedWriter(osw); 

      //creating message to send from standard input 
      String newmessage = ""; 
      try 
      { 
       // input the message from standard input 
       BufferedReader input= new BufferedReader( 
         new InputStreamReader(System.in)); 
       String line = ""; 

       line= input.readLine(); 
        newmessage += line + " "; 

      } 
      catch (Exception e) 
      { 
       System.out.println(e.getMessage()); 
      } 
      String sendMessage = newmessage; 
      bw.write(sendMessage + "\n"); 
      bw.flush(); 
      System.out.println("Message sent to client: "+sendMessage); 
     } 


     catch (IOException e) 
     { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     finally 
     { 

     } 
    } 
} 


} 

Code of Hauptfunktion Datei:

import java.io.IOException; 

public class DirectMessengerCombined 
{ 
    public static void main(String[] args) throws IOException 
    { 
     DirectMessengerClient Client1 = new DirectMessengerClient(); 
    // Thread t1 = new Thread(Client1); 
     DirectMessengerServer Server1 = new DirectMessengerServer(args); 
     //DirectMessengerServer Server1 = new DirectMessengerServer(args[1], null, 0); 
      for (int i = 0; i < args.length; i++) 
      { 
       if(!args[0].equals("-l")) 
       { 
        Client1.ClientRun(args); 
       } 
       switch (args[0].charAt(0)) 
       { 
        case '-': 
        if(args[0].equals("-l")) 
        { 
         Server1.ServerRun(args); 
        } 

       } 
      i=args.length + 20; 
      } 
    } 

} 

Meine Frage ist: Wo ist der richtige Ort, um die Verbindungen im Code zu akzeptieren, so dass beide laufen Methoden sein fähig zu arbeiten, als ob sie beide verbunden waren?

Answer 1

Normalerweise werden Sie es in eine Schleife in einem eigenen Thread einfügen, und Sie werden einen neuen Thread pro akzeptierte Verbindung starten.