Hallo,
ich habe folgende 3 Klassen erstellt:
Server:
Client:
ThreadKlasse:
Ich habe mich dabei an ein Tutorial gehalten und es versuchsweise ein wenig modifiziert..
Nun, sende ich von einem Client eine Nachricht, hängt er sich in der Methode NachrichtSchreiben in der Serverklasse auf. Solange bis ich im anderem Client eine Nachricht schreibe, dann gibt er mir erst in beiden Clients die Nachricht des im jeweilig anderem geschriebenem aus!
Nun, das verstehe ich nicht so recht, wie ich das anders hinbekomme! Vermutlich hängt er sich schon beim lesen auf und wartet auf bis von Serverseitens eine Antwort kommt, die aber nur kommen kann, wenn der andere Thread ebenfalls eine Nachricht eingelesen hat..
Naja, jedenfalls wäre ich erfreut wenn mir jemand diesen Sachverhalt erläutern könnte
! Ich habe jetzt expliziet keine mir verständliche Erklärung, oder ein besseres Beispiel anderswo gefunden!
gruß
ich habe folgende 3 Klassen erstellt:
Server:
Java:
public class Server {
int clients = 0;
public static void main(String[] args){
Server server = new Server();
try {
server.test();
}catch (IOException e){
e.printStackTrace();
}
}
void test() throws IOException {
int port = 11111;
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("Warte auf Anmeldung...");
Socket client1 = warteAufAnmeldung(serverSocket);
ErwarteNachricht ew1 = new ErwarteNachricht(client1);
Thread nachrichtVerwalter1 = new Thread(ew1);
nachrichtVerwalter1.start();
System.out.println("Warte auf 2. Client...");
Socket client2 = warteAufAnmeldung(serverSocket);
ErwarteNachricht ew2 = new ErwarteNachricht(client2);
Thread nachrichtVerwalter2 = new Thread(ew2);
nachrichtVerwalter2.start();
System.out.println("2 Clients sind erfolgreich angemeldet");
while(true){
//System.out.println("in while");
if(ew1.hatNachricht()){
String nachrichtClient1 = ew1.getNachricht();
System.out.println("Client1: " + nachrichtClient1);
schreibeNachricht(client2, "Client1: ", nachrichtClient1);
ew1.resetNachricht();
}
if(ew2.hatNachricht()){
String nachrichtClient2 = ew2.getNachricht();
System.out.println("Client2: " + nachrichtClient2);
schreibeNachricht(client1, "Client2: ",nachrichtClient2);
ew2.resetNachricht();
}
//System.out.println("end while");
}
}
Socket warteAufAnmeldung(ServerSocket serverSocket) throws IOException {
Socket socket = serverSocket.accept();
System.out.println("Client angemeldet!");
clients++;
return socket;
}
void schreibeNachricht(Socket socket,String vonClient, String nachricht) throws IOException {
PrintWriter printWriter =
new PrintWriter(
new OutputStreamWriter(
socket.getOutputStream()));
printWriter.print(vonClient+nachricht);
System.out.println(nachricht);
printWriter.flush();
}
}Client:
Java:
public class Client {
public static void main(String[] args){
Client client = new Client();
try{
client.test();
} catch (IOException e){
e.printStackTrace();
}
}
void test() throws IOException {
String ip = "127.0.0.1"; //localhost
int port = 11111;
Socket socket = new Socket(ip, port);
BufferedReader input= new BufferedReader(new InputStreamReader(System.in));
String textInput=null;
while(!"Exit".equals(textInput)){
textInput = input.readLine();
if(!textInput.equals(null)) schreibeNachricht(socket, textInput);
String empfangeneNachricht = leseNachricht(socket);
System.out.println(empfangeneNachricht);
}
}
void schreibeNachricht(Socket socket, String nachricht) throws IOException{
PrintWriter printWriter =
new PrintWriter(
new OutputStreamWriter(
socket.getOutputStream()));
printWriter.print(nachricht);
printWriter.flush();
}
String leseNachricht(Socket socket) throws IOException{
BufferedReader bufferedReader =
new BufferedReader(
new InputStreamReader(
socket.getInputStream()));
char[] buffer = new char[200];
int anzahlZeichen = bufferedReader.read(buffer, 0, 200); // blockiert bis Nachricht empfangen
String nachricht = new String(buffer, 0, anzahlZeichen);
return nachricht;
}
}ThreadKlasse:
Java:
public class ErwarteNachricht implements Runnable{
Socket client;
String nachricht;
ErwarteNachricht(Socket vonSocket){
this.client = vonSocket;
}
@Override
public void run() {
try {
nachricht = leseNachricht(client);
} catch (IOException e) {
e.printStackTrace();
}
}
String leseNachricht(Socket socket) throws IOException {
BufferedReader bufferedReader =
new BufferedReader(
new InputStreamReader(
socket.getInputStream()));
char[] buffer = new char[200];
int anzahlZeichen = bufferedReader.read(buffer, 0, 200); // blockiert bis Nachricht empfangen
String nachricht = new String(buffer, 0, anzahlZeichen);
buffer = null;
return nachricht;
}
boolean hatNachricht(){
try{
if(nachricht != null) return true;
}catch (NullPointerException e){
return false;
//e.printStackTrace();
}
return false;
}
String getNachricht(){
return nachricht;
}
void resetNachricht(){
nachricht = null;
}
}Ich habe mich dabei an ein Tutorial gehalten und es versuchsweise ein wenig modifiziert..
Nun, sende ich von einem Client eine Nachricht, hängt er sich in der Methode NachrichtSchreiben in der Serverklasse auf. Solange bis ich im anderem Client eine Nachricht schreibe, dann gibt er mir erst in beiden Clients die Nachricht des im jeweilig anderem geschriebenem aus!
Nun, das verstehe ich nicht so recht, wie ich das anders hinbekomme! Vermutlich hängt er sich schon beim lesen auf und wartet auf bis von Serverseitens eine Antwort kommt, die aber nur kommen kann, wenn der andere Thread ebenfalls eine Nachricht eingelesen hat..
Naja, jedenfalls wäre ich erfreut wenn mir jemand diesen Sachverhalt erläutern könnte
! Ich habe jetzt expliziet keine mir verständliche Erklärung, oder ein besseres Beispiel anderswo gefunden!gruß
