# Datenaustausch mit 2 Clienten und 1 Server hapert



## aloifolia (8. Jun 2007)

Hallo zusammen,
ich bin zur Zeit dabei, ein Spiel unter Java zu programmieren. Dabei soll es 2 Spieler und einen Server geben. Da der Server alle Berechnungen durchführt, müssen diesem über das Netzwerk die Tastaturereignisse der Spieler übermittelt werden.

Zuerst wird jedem Client/Spieler eine Kennung zugewiesen (0/1). Diese Kennung übermittelt jeder Sender (Clients und Server, letzter hat die 9) zur Identifizierung der Daten.

Die Tastaturereignisse, die mittels einer Klasse "Tastaturlauschen" verarbeitet werden - d.h. z.B. bei Key_Pressed: VK_UP wird "so1" übertragen. Dazu benutzt der Lauscher die Senden-Klasse, die dafür zuständig ist, über einen bereitgestellten Socket Texte zu übermitteln. Auf der anderen Seite wartet ein "Empfangen"-Thread auf Inhalte, die ebenfalls über einen zugeteilten Socket angekommen sind.

Nun kommt das Problem:
- Der als zweites gestartete Client kann erstmal, sobald er gestartet wurde, keine Ereignisse übertragen - er schreibt zwar auf, was er gesendet hat (diese Funktion habe ich als Kontrolle dazugeschrieben), aber ankommen tut beim Server nichts.
- Der zuerst gestartete Client kann zwar sofort Befehle übermitteln, sobald alle Verbindungen stehen, jedoch übermittelt er gleich doppelt so viel, wie er soll - beim Server gehen zum einen seine Ereignisse ein, zum anderen nochmal (anfangs) dieselben Ereignisse, aber mit der Kennung des anderen Clienten.
- Nach 1,2 Übermittlungen etwa tauschen die beiden Clients diese 2 Probleme untereinander aus. So geht das immer weiter

Nun meine Fragen: wie kann es sein, dass nicht beide gleichzeitig übermitteln können? Und wie kann es passieren, dass beim Server quasi die Befehle von zwei Clients gleichzeitig ankommen, obwohl nur bei einem Ereignisse ausgelöst wurden?

Hier erstmal meine Client- und Server-Klassen:


```
public class Client{
	static Verbindung bind;
	public static void main(String[] s) {
		Befehl c=new Befehl();     //Hier werden nur einfache Aktivitätsvariablen vom Typ boolean gespeichert

		JFrame j=new JFrame("test");JFrame ji;
		bind=new Verbindung(1,"client");
		j.addKeyListener(new Tastaturlauschen(c,bind,"client"));
		j.setVisible(true);
	}

}

public class Server {
	static Verbindung bind;
	public static void main(String[] s){
		konfigurieren();
		bind=new Verbindung(2,"server");
	}
}
```

Jetzt die Verbindungs-, anschließend die Empfangen- und Senden-Klasse:

```
//1.:

public class Verbindung{
	Socket[]socke; public Empfangen in; public Senden out;
	public int nummer=9; public boolean[]aktiv;
	ServerSocket server; 
	public Verbindung(int i, String s){
		try{
			if(s.equals("server")) server = new ServerSocket(2222);
		}
		catch(IOException e){
			System.out.println(e+"Verbindung geschlossen"); 
		}	
		socke=new Socket[i];
		aktiv=new boolean[i];
		try{
			if(s.equals("server")) System.out.println(i+" Client(s) noch ausstehend...");
			for(int j=0;j<i;j++) {
				if(s.equals("server")){
					aktiv[j]=false;
					socke[j] = server.accept();		
					System.out.println((i-j-1)+" Client(s) noch ausstehend...");
				}
				else
					while(true)
						try{
							socke[j]=new Socket("localhost",2222);
							break;
						}
						catch(ConnectException e){}
			}
			in=new Empfangen(socke,s,this); in.start();
			out=new Senden(socke,s,this); out.start();
			
		}
		catch(IOException e){
			System.out.println(e+" -> Verbindung geschlossen"); 	
		}
	}
}

//2.:

public class Empfangen extends Thread{	
	Socket[]socke;	
	BufferedReader[]in;
	String inmessage[],s;
	Verbindung bind;
	boolean spielrun=true;
	public Empfangen(Socket[]sockei, String si, Verbindung bindi){
		socke=sockei;
		in=new BufferedReader[socke.length];
		inmessage=new String[socke.length];
		s=si;
		bind=bindi;
	}
	public void run(){
		for(int i=0;i<socke.length;i++){
			try{		
				in[i] = new BufferedReader(new InputStreamReader(socke[i].getInputStream()));
				inmessage[i]="";
			}
			catch (Exception e) { 
				System.out.println(e+" -> ieVerbindung geschlossen");
			}
		}
		try{
			while(spielrun){
				for(int i=0;i<socke.length;i++){
					inmessage[i]=in[i].readLine();
					if(inmessage[i]!=null){
						reagieren(inmessage[i]);
						inmessage[i]=null;			//hat wohl keinerlei Funktion....
						//System.out.println(inmessage[i]);
					}
				}
				System.out.println("---");
				Thread.sleep(50);
			}
			for(int i=0;i<socke.length;i++){
				socke[i].close();System.out.println(i+" closed");
			}
		}
		catch (Exception e) { 
 			System.out.println(e+" -> eVerbindung geschlossen");
			System.exit(1);
		}
	}
	int i=0;
	public void reagieren(String s){
		
		if(s.length()>3){
			if(s.substring(1,4).equals("nbr")){
				String no=String.valueOf(s.charAt(4));
				System.out.print("Spielernummer: "+no);
				if(no.equals("0")) System.out.println(" --> links");
				else if(no.equals("1")) System.out.println(" --> rechts");
				bind.nummer=Integer.valueOf(no);
				bind.out.sendone(0,"aktiv");
				bind.aktiv[0]=true;
				//System.out.println(bind.nummer);
			}
			else if(s.substring(1,5).equals("text")){
				System.out.print("Sender:"+String.valueOf(s.charAt(0))+" Text:"+s.substring(5));
				System.out.println(" zaehler:"+i++);
			}
			else if(s.substring(1,6).equals("aktiv")){
				System.out.println(Integer.valueOf(String.valueOf(s.charAt(0)))+" aktiviert");
				bind.aktiv[Integer.valueOf(String.valueOf(s.charAt(0)))]=true;
			}
		}
	}
}

//3.:

public class Senden {
	Socket[]socke;
	PrintStream[]out;
	boolean spielrun=true;
	String s;
	Verbindung bind;
	public Senden(Socket[]sockei,String si, Verbindung bindi){
		socke=sockei;
		out=new PrintStream[socke.length];
		s=si;
		bind=bindi;
	}
	
	public void run(){	
		try{
			for(int i=0;i<socke.length;i++){
				out[i] = new PrintStream( socke[i].getOutputStream());
				if(s.equals("server")) sendone(i,("nbr"+i));
			}
			if(s.equals("server")) {
				System.out.println("Alle Clients verbunden, Spiel startet in Kuerze...");
				sendall("textAlle Clients verbunden, Spiel startet in Kuerze...");
			}
			else{
				System.out.println("Verbindung hergestellt...");
			}
		}
		catch (Exception e) { 
 			System.out.println(e+" -> sVerbindung geschlossen" ); 
		}
	}
	public void schliessen(){
		try{
			for(int i=0;i<socke.length;i++)
				socke[i].close();
		}
		catch(IOException e) { System.out.println(e+" -> Schliessen hat Fehler verursacht"); }
	}
	public void sendall(String s){
		for(int i=0;i<socke.length;i++){
			out[i].println(bind.nummer+s);
			out[i].flush();
		}
	}
	public void sendone(int i,String s){
		out[i].println(bind.nummer+s);
		out[i].flush();
		//System.out.println(bind.nummer+s);
	}
}
```

Und zu guter letzt noch die Tastaturlauschen-Klasse:


```
class Tastaturlauschen implements KeyListener{
	Befehl c;Verbindung bind;String sercli;
	
	public Tastaturlauschen(Befehl ci,Verbindung bindi,String serclii){
		c=ci;bind=bindi;sercli=serclii;
	}	
	
	public boolean aktiv(){
		for(int i=0;i<bind.aktiv.length;i++){
			if(bind.aktiv[i]==false) return false;
		}
		return true;
	}
	public void keyPressed(KeyEvent e){
		//if(aktiv()){
			if(e.getKeyCode()==KeyEvent.VK_UP){
				if(!c.oben[0]){
					bind.out.sendone(0,"textso1");
					System.out.println("so1");
				}
				c.oben[0]=true;	
			}
			if(e.getKeyCode()==KeyEvent.VK_DOWN){
				if(!c.unten[0]){
					bind.out.sendone(0,"textsu1");
					System.out.println("su1");
				}
				c.unten[0]=true;
			}
	//	}
	}
	public void keyReleased(KeyEvent e){
	//	if(aktiv()){
			if(e.getKeyCode()==KeyEvent.VK_UP){
				if(c.oben[0]){
					bind.out.sendone(0,"textso0");
					System.out.println("so0");
				}
				c.oben[0]=false;
			}
			if(e.getKeyCode()==KeyEvent.VK_DOWN){
				if(c.unten[0]){
					bind.out.sendone(0,"textsu0");
					System.out.println("su0");
				}
				c.unten[0]=false;
			}
		//}
	}
	public void keyTyped(KeyEvent e){}
}
```

Ich weiß, es ist sehr viel und hoffe, dass jemand eine Lösung weiß. Danke schonmal für eure Mühen.
Bastian


----------



## aloifolia (9. Jun 2007)

So,
in der gestrigen Nacht ereilte mich die Idee, die zur Lösung geführt hat. Falls jemand wissen will, woran es lag, schreibe ich es gerne auf.
Bis dahin,
Bastian


----------



## Hive [Gast] (9. Jun 2007)

Also mich würde es schon brennend interessieren


----------



## merlin2 (9. Jun 2007)

Mich auch.


----------



## aloifolia (19. Jun 2007)

Hi,
also nun doch noch eine, wenn auch verspätete, Antwort:

Der Fehler ist in der "Empfangen"-Klasse begründet.
Siehe:

```
inmessage[i]=in[i].readLine();
 if(inmessage[i]!=null){
    reagieren(inmessage[i]);
    inmessage[i]=null;                
 }
```

 Dort wird innerhalb der for-Schleife, die in der while-Schleife ausgeführt wird, welche sich innerhalb der run-Methode befindet, für alle Sockets obiger Code ausgeführt. Das blöde daran ist nun, dass der readLine-Befehl erst ausgeführt werden kann, wenn auch Daten vorliegen. D.h. wenn von Spieler 0 noch nichts übertragen wurde, von Spieler 1 hingegen schon, aber die for-Schleife noch bei der Ausführung für i=0 hängt, also auf einkommende Daten bei Socket 0, dann kann sie nicht weitergehen, um den BufferedReader von Socket 1 zu prüfen. Wenn dann schließlich mal Socket 0 etwas übertragen hat, wird der Reader gelesen und die for-Schleife führt auch die im 1. BufferedReader angesammelten Daten - natürlich nur die erste Zeile davon. Um die nächste zu lesen, muss wieder beim 0. Socket etwas ankommen, sodass die Schleife wieder zum 1. Reader springen kann.

Auf diese Art und Weise kann zum einen immer nur eine Anzahl von Wiederholungen etwas von einem BufferedReader eines Sockets gelesen werden - wahrscheinlich, bis der Reader des anderen Sockets leer ist. Zum anderen werden immer Daten aus zwei Sockets direkt nacheinander gelesen. Einmal der gerade eingegangene Strom, ein anderes Mal der angestaute andere.

Die Lösung ist nun, folgenden Code innerhalb der for-Schleife zu deklarieren: 

```
try{
	if(in[i].ready()){
		inmessage[i]=in[i].readLine();
		reagieren(inmessage[i]);
	}
	Thread.sleep(10);
 }
 catch(IOException e){ System.out.println(e.toString()); }
 catch(InterruptedException e){ System.out.println(e.toString()); }
```

Hier wird nun ganz einfach mit der ready-Methode abgefragt, ob neue Daten angekommen sind. Wenn dies der Fall ist, wird der BufferedReader gelesen und der String mit "reagieren" weiterverarbeitet. So kann direkt weitergesprungen werden zum nächsten Reader, falls keine Daten vorliegen. Zur geringeren CPU-Auslastung habe ich noch einen Sleeper eingebaut mit 10 Millisekunden Schlafzeit für jeden Schleifendurchlauf.

MfG Bastian


----------

