Socket Multithread-Socket | Kurz vor dem Ziel

[DeBukkIt]

Hallo Java-Freunde!

Zu Anfang möchte ich euch sehr herzlich für eure Hilfe bei meinen vorangegangenen (ich glaube drei) Posts danken! Wie ich dort häufig erwähnte programmiere ich in Java Technik für ein Funkspiel.
Ich bin mit einem Status-Geber (Client sendet ein paar Bytes an den Server etc.) und einem Login-Server (Client sendet Login-Daten, Server kontrolliert sie und schickt ein boolean zurück etc.) fertig und überaus glücklich.
Von Anfang an war jedoch der schwierigste Teil der umgekehrte Weg: Die Alarmierung. Die Clients müssen sich mit dem Server verbinden und die Verbindungen müssen ununterbrochen parallel gehalten werden. Dazu müssen ja wohl Threads eingesetzt werden. Bis jetzt kann ich dieses Halten der Verbindung nur mit einem einzigen (dem zuletzt verbundenen Client) schaffen.
Für die Filterung (welcher der Clients jetzt auf eine Alarmierung reagiert) habe ich schon eine Lösung gefunden, indem er die erste Zeile des gesendeten überprüft, ob sie seine ID enthält: Kein Problem.

Das Problem bleibt:
Wie kann ich die Verbindungen zu mehreren Clients via Thread halten?

Als Referenz-Werk dient mir "Java ist auch eine Insel" (9. Auflage) von C. Ullenboom, was mir bei diesem Problem leider nicht weiterhilft. Es beschreibt nur getrennt voneinander Threads und Netzwerk-Programmierung.

Ich stehe so kurz vor meinem Ziel, an dem ich schon so lange arbeite. Ich brauche nur diese Lösung, diesen einen Code-Schnipsel. Ich hoffe, dass jemand von euch eine Lösung parat hat.


Herzlichen Danke im Voraus,
DeBukkIt

 

[Xeonkryptos]

Du erstellst bei jedem Verbindungsaufbau von einem Client mit dem Server einfach einen neuen Thread, den du dann in einer Liste bzw Map mit allen anderen hälst. Nach dem erfolgreichen Verbindungsaufbau lässt du den Server einfach weiter auf eine neue Verbindung warten und startest dann wieder einen neuen Thread, speicherst ihn, und fängst von vorne an. Immer so weiter.

So etwas wie das hier, zum Beispiel:

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class TServer {

	private List<Socket> socketList = new ArrayList<Socket>();
	private List<Thread> threadList = new ArrayList<Thread>();

	public void run() {
		try {
			while (true) {
				saveNewSocket(new ServerSocket(1234).accept());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void saveNewSocket(Socket socket) {
		Thread clientHandler = new Thread(new ClientHandler());
		clientHandler.start();
		socketList.add(socket);
		threadList.add(clientHandler);
	}
}

Hier ist zu beachten, dass der ClientHandler das Interface Runnable implementiert. Außerdem, dass die Listen auch durch eine Map oder irgendeine andere Datenstruktur ersetzt werden können, je nachdem, was man gerade benötigt.

 

[DeBukkIt]

Hallo Xeonkryptos,

danke für die schnelle Antwort und das Beispiel!
Leider weiß ich mit dem clientHandler nichts anzufangen, da der Client quasi nicht gehandelt wird. Sein printStream wird von der Klasse aufgerufen, die die paar Zeilen an ihn sendet. Daher muss nach dem Verbindungsaufbau nichts mehr erfolgen. Wie muss ich die Zeilen

Thread clientHandler = new Thread(new ClientHandler());
clientHandler.start();

dann behandeln? Einfach auslassen?

Danke,
DeBukkIt

 

[Xeonkryptos]

Du kannst natürlich die beiden Zeilen weglassen, nur dann hast du kein Multi-Threading. An dieser Codestelle wird nach jeder neu eingegangenen Verbindung ein neuer Thread aufgebaut.
Der ClientHandler würde in meinem Beispiel dann einfach nur die Klasse sein, die dann dem Client über dem printStream das schickt, was geschickt werden soll.

 

[Sinnvoll?]

Sorry ... aber was bitte is das denn für ein totaler Schwachsinn

while (true) {
                saveNewSocket(new ServerSocket(1234).accept());
            }

AUA ... da wird mir ja ganz anders.

@TO

Fang doch erstmal mit was ganz einfachem an : einem Chat-System.
Hier ein sehr gutes Tut : KLICK
Ist zwar ziemlich veraltet und nutzt deprecated aber an sich kann man damit anfangen.

 

[DeBukkIt]

Der nicht angemeldete Nutzer über mir muss das Problem entdeckt haben, das sich mir gerade eröffnet hat:
java.net.BindException: Address already in use: JVM_Bind

Genau an der Stelle

		        try {
		            while (true) {
		                saveNewSocket(new ServerSocket(8114).accept());
		            }
		        } catch (IOException e) {
		            e.printStackTrace();
		        }

gibt es beim 2. Durchlauf der while(true)-Schleife die Exception 😱

 

[Poltergeist]

DeBukkIt
die schleife mit dem server is nicht nur das problem, sondern auch ein gewagtes spiel. Korrect waere:

try {
          ServerSocket ss = new ServerSocket(8114);
          while (true)  aveNewSocket(ss.accept());
} catch (IOException e) {
            e.printStackTrace();
}

 

[Xeonkryptos]

Ups... Sry, das war mein Fehler. 😳 Natürlich muss das vorher deklariert werden und dann in der Schleife immer die accept-Methode neu aufgerufen. Hatte das einfach nur ganz schnell abgetippt, um ein Beispiel zu zeigen und hatte nicht mehr drübergeschaut, ob das auch wirklich funzt... Kleines Missgeschick. 🙂