Multithreaded-Server

[jono]

Hallo,

ich möchte eine TcpClient-Server Verbindung aufbauen. Das Problem ist jetzt erstmal in der TcpServer Klasse.

public class TcpServer extends Thread {

    private static int PORT = 12345;
    private static String UTF8_CHARSET = "UTF-8";
    AtomicBoolean running = new AtomicBoolean(true);

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(PORT);
        System.out.println("TcpServer listening on port " + PORT);

        while (running) {
            Socket clientSocket = serverSocket.accept();
            TcpClient t = new TcpClient() {
                public void run() {

                    System.out.println("  connected to " + clientSocket.getInetAddress()
                                                                       .getHostName()
                            + " (" + clientSocket.getInetAddress()
                                                 .getHostAddress()
                            + ")");
                    System.out.println("  local port: " + clientSocket.getLocalPort());
                    System.out.println("  remote port: " + clientSocket.getPort());

                    try (BufferedReader in = new BufferedReader(
                            new InputStreamReader(clientSocket.getInputStream(), Charset.forName(UTF8_CHARSET)));

                            PrintWriter out = new PrintWriter(new OutputStreamWriter(clientSocket.getOutputStream(),
                                    Charset.forName(UTF8_CHARSET)), true)) {
                        out.println("Welcome, client! I'll translate your input to uppercase :-)");
                        for (String line = in.readLine(); line != null; line = in.readLine()) {
                            out.println(line.toUpperCase());
                        }

                        System.out.println("Client closed connection.");
                    }

                    catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            };
            t.start();

        }

    }
}

Ich muss natürlich noch den Thread terminieren und die Socket-Verbindung auch, aber eins nach dem anderen. Nun ist es so, dass running und .start() rot unterstrichen werden. Zu running: Dort steht change running to static und bei .start() steht "The method start() is undefined for the type TcpClient"...
Ich bin gerade mega verwirrt, weil ich das zum ersten Mal mache... Kann mir jemand einen guten Hinweis geben? Ziel ist es ja letztendlich, dass sich mehrere Clients im Server "einloggen" können

 

[Oneixee5]

Du erstellst nie eine Instanz deines TcpServer's. Deshalb kommt der Hinweis die Methoden static zu machen.

 

[Oneixee5]

Es ist eine "bad practices" die Klasse Thread zu überschreiben. Normalerweise implementiert man Runnable.

public class App {
    public static void main(String[] args) {

        Runnable target = new Runnable() {

            public void run() {
                // do somthing
            }
            
        };
        Thread thread = new Thread(target);
        thread.start();
    }

}

Rheinwerk Computing :: Java SE 8 Standard-Bibliothek - Threads und nebenläufige Programmierung

openbook.rheinwerk-verlag.de

Aber auch das ist sehr "old school". Seit Java 5 gibt es viel bessere Verfahren mit Nebenläufigkeit/Threads umzugehen, z.B.: die Schnittstelle Executor

 

[jono]

Okay, ich möchte doch auch keine erstellen und es kommt ja nicht der Hinweis die Methoden static zu machen, sondern nur das AtomicBoolean-Objekt?

 

[jono]

Könntest du mir eventuell trotzdem bei der old-school Variante weiterhelfen, sollen wir erstmal so machen !

 

[Oneixee5]

Könntest du mir eventuell trotzdem bei der old-school Variante weiterhelfen, sollen wir erstmal so machen !

private static AtomicBoolean running = new AtomicBoolean(true);

 

[Oneixee5]

Könntest du mir eventuell trotzdem bei der old-school Variante weiterhelfen, sollen wir erstmal so machen !

while (running.get()) { ...

 

[kneitzel]

Irgendwie fällt mir hier nicht wirklich viel zu ein ...

Könntest du mir eventuell trotzdem bei der old-school Variante weiterhelfen, sollen wir erstmal so machen !

Mein Gedanke ist da jetzt im Augenblick nur: Wie hast Du es zwei Jahre lang geschafft, Dich durch zu mogeln ohne auch ansatzweise die Java Grundlagen zu lernen?

Ja, das wird Dir nicht weiter helfen, aber mir fällt nichts ein, was Dir wirklich weiter helfen würde. Das
private static AtomicBoolean running = new AtomicBoolean(true);
mag zwar ein Compile-Fehler beheben, aber es wird Dich nicht wirklich weiter bringen fürchte ich.

Das, was Du da bauen sollst geht weit über "Wie mache ich eine Variable verfügbar in einer statischen Methode". Gewisse Grundlagen sollten halt da schon durchaus vorhanden sein (vermutlich das, was die letzten 2 Jahre so alles vorgekommen ist in Vorlesungen und Übungen).

Aber ich bin schon ruhig - denn irgendwie ist das alles ja nicht wirklich konstruktiv, was ich beitragen kann.

 

[jono]

Kannst du mir denn nicht vielleicht sagen wo ich etwas verbessern kann/muss, was evtl nicht in den Thread gehört, und konstruktiv ist es auf jeden Fall auch wenn du nicht den Eindruck hast.
Ich meine Netzwerkprogrammierung habe ich jetzt noch nicht gemacht.
An welcher Grundlage wäre es denn hier gescheitert oder vielleicht auch an welchen/allen?

 

[jono]

Ja, das wird Dir nicht weiter helfen, aber mir fällt nichts ein, was Dir wirklich weiter helfen würde. Das
private static AtomicBoolean running = new AtomicBoolean(true);
mag zwar ein Compile-Fehler beheben, aber es wird Dich nicht wirklich weiter bringen fürchte ich.

Der Meinung war ich doch gar nicht..

 

[mihe7]

Ich würde mal damit anfangen, running als lokale Variable von main zu deklarieren. Der nächste Schritt wird sein, dass Du Dir die Doku zur Klasse AtomicBoolean anschauen werden musst.

 

[jono]

Ich würde mal damit anfangen, running als lokale Variable von main zu deklarieren.

Warum macht man das so am besten?

Der nächste Schritt wird sein, dass Du Dir die Doku zur Klasse AtomicBoolean anschauen werden musst.

Atomare Variablen sind ja dazu da, gemeinsam genutzte Ressourcen von Threads threadsicher zu machen und Inkonsistenzen zu vermeiden, sodass sie sich nicht dazwischen funken. Ich dachte, wenn ich die so setze, wie sie dort gesetzt ist, ist das ganze threadsicher. Kann es denn sein, dass die while-Schleife in die run-Methode gehört, weil es dort wird ja dann die atomare Variable von den Threads "genutzt"?

 

[jono]

Ich möchte ja die Threads auch irgendwann terminieren bzw. stoppen. Das möchte ich eigentlich darüber machen. Ich gebe Ja auch zu, dass ich auch ein wenig Verständnisprobleme habe und gerade nicht genau weiß ob das ganz so sinnvoll ist die running zu deklarieren bzw. zu implementieren.

 

[mihe7]

Warum macht man das so am besten?

Weil du aktuell keinen größeren Gültigkeitsbereich brauchst. (EDIT: wobei ich nicht meinte, dass Du das am besten so machen sollst, sondern einfach mal als ersten Schritt. Du kannst auch running als Klassenvariable deklarieren).

Atomare Variablen sind ja dazu da

Das war gar nicht mal die Frage. Wenn Du running statisch oder als lokale Variable deklarierst, wird Dein while (running) immer noch rot unterringelt werden. Zusammen mit der Doku zu AtomicBoolean solltest Du das behoben bekommen.

 

[kneitzel]

Kannst du mir denn nicht vielleicht sagen wo ich etwas verbessern kann/muss, was evtl nicht in den Thread gehört, und konstruktiv ist es auf jeden Fall auch wenn du nicht den Eindruck hast.
Ich meine Netzwerkprogrammierung habe ich jetzt noch nicht gemacht.
An welcher Grundlage wäre es denn hier gescheitert oder vielleicht auch an welchen/allen?

Wenn Du etwas entwickeln willst in einer objektorientierten Sprache, dann solltest Du versuchen, in Objekten zu denken.

Dann hast Du also einen TcpServer. Und der hat dann Eigenschaften. Das kann durchaus ein running sein. (Ich würde es nicht als lokale Variable machen, denn das ist ein Zustand, der auch von außen für andere Objekte interessant sein kann.)
Weitere Eigenschaften sind ggf. noch der Port und so. Und was später sonst noch so kommt.

Dann gibt es da keine main Methode. Was hat ein TcpServer ein globales main Verhalten? Ok, das mag evtl. am Anfang interessant sein als eine Art "Unit Test für Arme", aber da würde ich eher schauen, mich langsam Richtung Unit Tests zu orientieren....
Aber ok - du kannst da eine Klasse Main oder so haben und da kommt dann die main Methode rein.

Was macht die main Methode? Sie erstellt eine TcpServer Instanz. Dazu gibst Du ggf. einen Port mit an, ggf. gibt es einen default port. Und dann startest Du den TcpServer...

[CODE lang="java" title="Main"]public class Main {
public static void main(String[] args) {
TcpServer server = new TcpServer();
server.start();
}
}[/CODE]

public class TcpServer extends Thread {

    public static finalint DEFAULT_PORT = 12345;
    
    private int port;
    private AtomicBoolean running = new AtomicBoolean(false);
    private ServerSocket serverSocket;
    private Thread serverThread;
    
    public TcpServer() {
        this(DEFAULT_PORT);
    }
    
    public TcpServer(final int port) {
        this.port = port;
    }
    
    // Getter port
    
    public boolean isRunning() {
        return running.get();
    }
    
    public void start(String[] args) throws IOException {
        serverSocket = new ServerSocket(PORT);
        serverThread = new Thread(this::acceptNewSocketsLoop);
        serverThread.start();
        System.out.println("TcpServer listening on port " + PORT);
    }
    
    public void acceptNewSocketsLoop() {
        running.set(true);
        while (running.get()) {
            Socket clientSocket = serverSocket.accept();
            TcpClientHandler newClient = new TcpClientHandler(clientSocket);
            newClient.start();
        }
    }
}

Das einfach mal auf die Schnelle im Forum geschrieben. Tippfehler oder Syntax-Fehler bitte entschuldigen. Es dürfte aber deutlich sein, worauf es hinaus läuft. Auch beim Wording aufpassen. "TcpClient" wäre, wenn ich TcpServer und TcpClient habe, nach meinem Verständnis eher der Gegenpart, der dann Verbindung zu dem Server aufnimmt. Nicht die Behandlung einer Connection. Das habe ich mal TcpClientHandler genannt - etwas, das mit dem TcpClient umgeht. Aber ConnectionHandler wäre evtl. noch besser, denn es wird eine konkrete, eingegangene Verbindung behandelt.

So eine Klasse würde ich auch weniger als innere Klasse machen, aber das ist natürlich Geschmackssache. Zum einen werden ggf. andere Klassen Zugriff darauf bekommen. Zum Anderen bläht es eine Klasse groß auf was ich unübersichtlich finde.

Unabhängig von diesen Dingen konnte ich aber aufzeigen, wie man hier objektorientiert arbeiten kann. Es entsteht ein Objekt. Das da intern ein Thread läuft, das hat doch nichts mit dem Interface zu tun. Das passiert intern. Das ist auch eine Form der Kapselung.

Aus CleanCode Sicht: Ich vermeide jedes new blabla() { ... }! Das ist extrem unleserlich! Bei funktionalen Interface ist mindestens ein Lambda eine gute Verkürzung. Und wenn da mehr als eine Zeile benötigt wird, dann kommt das in eine Methode so dass ich automatisch eine Dokumentation habe, was die Zeilen machen:

schreibeHilfreichenBeitragImForum() {
    geheAufAntworten();
    schreibeGruss(GRUSSLAENGE.KURZ);
    fuegeTextEin();
    sendeBeitragAb();
}

Klar: Man kann den Code lesen und dann erkennen, was da wohl passiert. Aber der Methodenname macht schon klar, was da passiert und es ist sofort verständlich.

Und mit der Methode kann man aus dem Lambda eine Methodenreferenz machen.

 

[jono]

Okay.
In die TcpClientHandler-Klasse sollte ich dann die Reader und Writer schreiben? Und System.out.println(...), die halt dazu gehören?
Die Dinge müssten dann ja auch in eine run-Methode gepackt werden, richtig?

Eine andere Frage:

public void start(String[] args) throws IOException { serverSocket = new ServerSocket(PORT); serverThread = new Thread(this::acceptNewSocketsLoop); serverThread.start(); System.out.println("TcpServer listening on port " + PORT); }

Hier hast du die acceptNewSocketsLoop-Methode als Parameter des Thread-Objekts benutzt. Muss man dann, um den serverThread starten zu können, nicht noch eine andere run_Methode schreiben, damit man ihn starten kann?
Habe gerade mal versucht das herauszufinden, aber nichts dazu gefunden, wieso man jetzt, wie in dem Fall dem Thread Objekt, ein Parameter mitgeben kann, eher gesagt welche...

 

[jono]

public void start(String[] args) throws IOException { serverSocket = new ServerSocket(PORT); serverThread = new Thread(this::acceptNewSocketsLoop); serverThread.start(); System.out.println("TcpServer listening on port " + PORT); }

Und wieso benutzt man hier das String[] args als Parameter?

 

[jono]

public TcpServer() { this(DEFAULT_PORT); } public TcpServer(final int port) { this.port = port; }

Ich habe auch nicht verstanden, warum du das gemacht hast. Kannst du mir das bitte auch kurz erläutern?
Danke für deine/eure Hilfe.

 

[temi]

Und wieso benutzt man hier das String[] args als Parameter?

Tatsächlich benutzt man es im Beispiel nicht und könnte es auch weglassen. Solltest du aber später die Anforderung erfüllen müssen, z. B. den Port als Aufrufparameter mitzugeben, dann kannst du es so verwenden.

Aber was nicht gefordert ist, sollte man auch nicht implementieren. Ich nehme an es ist ein Copy & Paste Überbleibsel.

 

[temi]

Ich habe auch nicht verstanden, warum du das gemacht hast. Kannst du mir das bitte auch kurz erläutern?
Danke für deine/eure Hilfe.

Das sind einfach zwei Konstruktoren, einmal ohne und einmal mit einem Parameter (für den zu verwendenden Port).

Das sind Basics, die du im Schlaf beherrschen solltest.

 

[jono]

Das sind einfach zwei Konstruktoren, einmal ohne und einmal mit einem Parameter (für den zu verwendenden Port).

Das sind Basics, die du im Schlaf beherrschen solltest.

Ja, dass das Konstruktoren sind ist offensichtlich. Mir hat es eher an Verständnis gefehlt, warum zwei Stück bzw. warum einmal mit und einmal ohne Parameter?

 

[kneitzel]

Okay.
In die TcpClientHandler-Klasse sollte ich dann die Reader und Writer schreiben? Und System.out.println(...), die halt dazu gehören?
Die Dinge müssten dann ja auch in eine run-Methode gepackt werden, richtig?

Ja, der TcpClientHandler würde dann mit den Streams des Sockets arbeiten und wäre vor allem für den Empfang zuständig. Das sollte halt nur ein kleiner Rahmen sein, der etwas die mögliche Struktur aufzeigt.

Hier hast du die acceptNewSocketsLoop-Methode als Parameter des Thread-Objekts benutzt. Muss man dann, um den serverThread starten zu können, nicht noch eine andere run_Methode schreiben, damit man ihn starten kann?

Nein, hier solltest Du einmal das Thema Functional Interface betrachten und wie man da mit Lambda Ausdrücken und Methoden Referenzen arbeiten kann.

Habe gerade mal versucht das herauszufinden, aber nichts dazu gefunden, wieso man jetzt, wie in dem Fall dem Thread Objekt, ein Parameter mitgeben kann, eher gesagt welche...

Wo willst Du denn was mit übergeben?

Und wieso benutzt man hier das String[] args als Parameter?

Das ist einfach ein kleiner Copy Fehler würde ich sagen. Ich habe halt einfach Code von Dir hin und her geschoben. Die Parameter werden nicht benutzt und sollten auch nicht wirklich da sein. Der Aufruf erfolgte ja auch ohne Parameter. Sowas passiert, wenn man nicht in einer IDE sondern in einem Forum mit begrenztem Editor etwas zusammen stellt.

Ich habe auch nicht verstanden, warum du das gemacht hast. Kannst du mir das bitte auch kurz erläutern?
Danke für deine/eure Hilfe.

Das mit dem Port ist einfach so ein 08/15 Pattern. Du hast einen default Wert (hier den Port, der verwendet werden soll). Denn kann man beim Konstruktor angeben. Aber man kann es auch ohne aufrufen - dann nimmt er halt den default port.