Java Client/Server warten auf Nachichten

[Bender86]

Hallo zusammen!

Ich übe grade ein bisschen den Umgang mit Sockets und der Kommunikation zwischen einem (sehr simplen) Server und Client. Bisher läuft es bei mir so, dass sobald ein Client beim Server verbindet der Server einen Thread startet, der in einer Endlosschleife guckt ob eine Nachicht im (Object-)InputStream angekommen ist. (Die Nachichten werden in einer Wrapper-Klasse verpackt verschickt)

Ich vermute mal das das ziemlich unperformant ist wenn da ein Thread ständig guckt "Ist was für mich da?". In technischer Informatik haben wir auch gelernt das es für sowas in C ein wait/signal gibt wodurch ein Thread schläft bis ein bestimmtes Signal kommt das ihn wieder aufweckt.

Weiß jemand womit ich das bei Java mache? Sprich ich habe einen Thread beim Server der wartet bis er ein Signal vom Client bekommt, dass eine Nachicht angekommen ist? (Und andersrum natürlich auch)

Viele Grüße,
Bender

 

[x-zet0r]

Hi, ich habe dies wie folgt gelöst.

try {
            ServerSocket serverSocket = new ServerSocket(1337); // <-- Port
            logger.info("server socket allocated");
            while (true) {
                Socket socket = serverSocket.accept();  // Hier bleibt der Thread stehen bis eine Verbindung eingeht
                logger.info("connection accepted");
                Thread serverThread = new ServerThread(socket);
                serverThread.start();
            }
        }
        catch (IOException e) {
           e.printStackTrace(); 
}

public class ServerThread extends Thread {

     private static int cnt;
     private InputStreamReader reader;

     public ServerThread(Socket socket) {
        super("server-" + ++cnt);
        try {
            reader = new InputStreamReader(socket.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Hier wird dein Empfang in nen seperaten Thread gehandhabt.
     */
    public void run() {
        logger.info("server thread started");
        try {
            while (true) {
                char[] cbuf = new char[1024];
                int len = reader.read(cbuf);             
                logger.debug("message received");
                if (len > 0) {
                    String text = String.copyValueOf(cbuf, 0, len);
                    System.out.println(">> " + text);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Hoffe das hilft.

 

[caligo]

gelöscht

E2:
aus der Java API

read

public abstract int read()
throws IOException

Reads the next byte of data from the input stream. The value byte is returned as an int in the range 0 to 255. If no byte is available because the end of the stream has been reached, the value -1 is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.

A subclass must provide an implementation of this method.

Returns:
the next byte of data, or -1 if the end of the stream is reached.
Throws:
IOException - if an I/O error occurs.

 

[Bender86]

Ja, so ähnlich habe ich das auch. Aber dort hat man ja eine Endlosschleife, die die ganze Zeit:

            while (true) {
                char[] cbuf = new char[1024];
                int len = reader.read(cbuf);             
                logger.debug("message received");
                if (len > 0) {
                    String text = String.copyValueOf(cbuf, 0, len);
                    System.out.println(">> " + text);
                }
            }

Macht. Was ich aber eben entdeckt habe ist:

read

public abstract int read()
throws IOException

Reads the next byte of data from the input stream. The value byte is returned as an int in the range 0 to 255. If no byte is available because the end of the stream has been reached, the value -1 is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.

A subclass must provide an implementation of this method.

Returns:
the next byte of data, or -1 if the end of the stream is reached.
Throws:
IOException - if an I/O error occurs.

Also wartet read() dort bis etwas angekommen ist richtig? Womit das Problem eigentlich gelöst ist. Ich dachte der Thread macht die ganze Zeit read()... read()... read()... read().. bis der Scheduler einem anderen Thread Rechenzeit zuweist. Dabei gibt der Thread automatisch ab sobald nichts mehr im InputStream ist oder?


/edit

Hehe da hats noch jemand gelesen. Danke euch beiden.

 

[SheepShaver]

Wenn es dir nur darum geht, ein Messaging zwischen Client und Server zu implementieren, warum verwendest du nicht JMS?

 

[Bender86]

Es geht mir hauptsächlich darum, ein bisschen ein Gefühl für Sockets und Threads zu bekommen und wie man Daten zwischen einem Client und Server hin und her schicken kann. Da ich grad im 3. Semester bin und nächstes Semester bei unserem Softwareprojekt die Implementierung ansteht will ich mich schonmal ein bisschen einarbeiten damit die Implementierungsphase nicht so stressig wird.