threaded server

[käsekuchen]

Guten Abend

Bin gerade an einem Tutorial für die Netzwerkprogrammierung und probiere einen Quellcode zu verstehen

Kann mir jemand erklären was genau

while (true) {
                if (input.available() == 0) ;
                    System.out.println("input available");
                    input.read(b);
                    String clientName = new String(b);
                    Server.print(klassenname + ":\tName empfangen: " + clientName);
}

hier passiert?
Warum funktioniert das hier nicht:

while (true) {
                if (input.available() == 0) {
                    System.out.println("input available");
                    input.read(b);
                    String clientName = new String(b);
                    Server.print(klassenname + ":\tName empfangen: " + clientName);


                }
}

Wollte das Programm nämlich so umschreiben, wenn

(input.available)

ungleich 0 ist, dass dann die schleife trotzdem noch durchläuft und somit auch was vom server gesendet werden kann!

Außerdem: warum eigentlich

 if (input.available() == 0)

? heißt available nicht verfügbar und somit wäre 0 doch schlecht, im sinne von nicht verfügbar =/.

Hoffe ihr könnt mir helfen

Fehler ist, dass nichts ankommt bei meiner (der 2.) lösung

grüße

 

[Kevin94]

Wo hast du das her? Wenn das der vollständige Quellcode ist, macht er definitiv keinen Sinn. Ohne ein else ist die erste Version volkommen sinnfrei, da man das if einfach streichen könnte ( ; am Ende der Zeile) und immer versucht wird zu lesen. Der zweite Ausschnitt ist auch nicht ganz korrekt, wenn man aber == 0 durch != 0 ersetzen würde, hätte man zumindest einen logisch funktionierendes Grundgerüst.

 

[käsekuchen]

ich habe den code aus dem buch "Java als erste Programmiersprache", allerdings schon verändert. ursprünglich hieß es

while(input.available() == 0)

. Vielleicht habe ich auch nur nicht genau verstanden, was input.available heißen soll.
Ich dachte das bedeutet: Solange etwas vom clienten geschickt wird!
und deswegen habe ich darum eine while(true) schleife gemacht, die überprüft ob etwas gesendet wird, aber danach noch weiter läuft, damit der server auch was schicken kann.

Das ist da gar nicht gut erklärt! Und im Internet finde ich auch nichts gutes. Immer nur von server zu client oder andersrum.

Kann mir jemand hier ein Tutorial empfehlen?

 

[AmunRa]

Nein available() gibt zurueck wieviele Bytes verfuegbar sind. das heist available ==0 ist true wenn nichts verfuegbar ist.

in deiner zweiten If bedingung wird nur hineingegangen wenn keine Bytes vorhanden sind die gelesen werden koennen.


ich nehme mal an , dass deine wihle schleife vorher so aus gesehen hat
[c]while(input.available()==0) ;[/c]

das Semikolon zum schluss ist hier wichtig. Das Codesegment bedeutet naehmlich, dass der Server an der whileschleife solange haengt bis eine input available ist. (Peroenlich gefaellt mir so eine Loesung nicht, aber sie funktioniert)

 

[käsekuchen]

vielen dank!
Ich habe das Semikolon so verstanden, dass alles was danachkommt in quasi in der while-Schleife ist!
Deswegen habe ich mich auch schon gewundert, warum das 0 sein muss! Will natürlich auch keinen Mist lernen, was wäre denn deiner Meinung nach eine bessere Möglichkeit?

Nett, dass man hier so schnell Hilfe bekommt!

Habe jetzt mal meinen Code etwas abgeändert

class WorkerThread extends Thread {

    private Socket socket;

    public WorkerThread(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        try {         
            byte[] b = new byte[128];
            InputStream input = socket.getInputStream();

            System.out.println("1");
            while (input.available() == 0);
            System.out.println("2");
            
            input.read(b);
            String in = new String(b);
            System.out.println(in);

            socket.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void send(String s) {
        try {
            OutputStream output = socket.getOutputStream();
            byte[] antwort = (s).getBytes();
            output.write(antwort);
        } catch (Exception e) {
        }
    }
}

Würde das so funktionieren? habe noch keine oberfläche geschrieben, mit der ich es testen könnte!

Und ich bitte um Verbesserungsvorschläge!

lG

 

[AmunRa]

Ja es wuerde so funktionieren.

Das muesstest du ja durch ausprobieren schon herausgefunden haben.
Aber dadurch kannst du nur einmal etwas von deinem Socket lesen. da danach der socket geschlossen wird und du die run methode verlaesst.

ich wuerde nicht auf available warten, sondern einfach die read methode aufrufen, da diesen den Thread solange blockiert bis eine Input vorhanden ist.

Reads some number of bytes from the input stream and stores them into the buffer array b. The number of bytes actually read is returned as an integer. This method blocks until input data is available, end of file is detected, or an exception is thrown.

 

[käsekuchen]

muss ich die/den socket denn schließen? was passiert denn wenn ich es nicht mache. warum überhaupt schließen, ich will doch die verbindung nicht trennen!

while (input.available() == 0);

also einfach rausnehmen?

Probiere das direkt mal aus, danke

 

[käsekuchen]

achso: Wäre es dann nicht sinnvoll Client auch von Thread erben zu lassen? Weil durch eine while(true) schleife ließen sich ja keine anderen methoden, zum senden, mehr aufrufen.

 

[Volvagia]

Ich würde einen Thread zum Lesen und einen für das Hauptprogramm verwenden.
Aber du musst bedenken, dass du mehr Speicher bereitstellst als du für vermutlich benötigst:

Länge im Stream geschrieben: 10
Länge vom Stream gelesen: 128

Da du einen Speicher mit 128 Bytes erzeugst und die bytes des Streams darüber hinein schreibst, wird zuerst der "Haupttext" und danach nur noch nullen als Chars im String stehen.Das könntest du mit einen trim lösen der die Null-Chars entfernt. Ich würde dir als Anfänger aber empfehlen auf BufferedReader zu setzen. Diese können von Haus aus den Text bis zum nächsten Zeilenumbruch lesen und zurückgeben.

Außerdem kannst du nur 128 Zeichen auf einmal lesen, das kannst du mit einer Schleife lösen.


Testklasse:

public class WorkerThread extends Thread {
    private Socket socket;
 
    public WorkerThread(Socket socket) {
        this.socket = socket;
    }
 
    public void run() {
        try {         
            byte[] b = new byte[128];
            InputStream input = socket.getInputStream();
 
            //System.out.println("1");
            //while (input.available() == 0);
            //System.out.println("2");
            
            input.read(b);
            String in = new String(b);
            //System.out.println(in);
            System.out.println("Länge vom Stream gelesen: " + in.length());
 
            socket.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public void send(String s) {
        try {
            OutputStream output = socket.getOutputStream();
            byte[] antwort = (s).getBytes();
            output.write(antwort);
        } catch (Exception e) {
        }
    }
    
    public static class TestClass {
    	public TestClass() {
    		super();
		}
    	
    	@Test
        public void testThis() {
        	new Thread() {
        		public void run() {
        			ServerSocket ss;
    				try {
    					ss = new ServerSocket(1025);
    					Socket toClientSocket = ss.accept();
    	    			new WorkerThread(toClientSocket).start();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
        		}
        	}.start();
        	//Möglicherweiße warten
        	try {
        		String outputText = "java-forum";
                System.out.println("Länge im Stream geschrieben: " + outputText.length());
        		
    			Socket toServerSocket = new Socket("127.0.0.1", 1025);
    			WorkerThread worker = new WorkerThread(toServerSocket);
    			worker.send(outputText);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
        }	
    }
}

 

[käsekuchen]

habe ich das dann richtig verstanden, dass die ausgegebenen Strings die nullen beinhalten?
bei mir werden nämlich keine ausgegeben. Oder ist es eher ein Problem was man nicht sieht. Was ist denn der Nachteil wenn ich es nicht mache.

Ich muss jetzt leider los, aber danke für die Antowrten bisher! Spätestens morgen melde ich mich nochmal und probiere das mit dem Buffered Reader, falls das besser ist!

Grüße

 

[Volvagia]

Nicht besser, nur anderst.

Byte-Array nach der Erzeugung: (10 Felder Länge)

0 0 0 0 0 0 0 0 0 0

Möglicher Stream-Inhalt: (ABC)

65 66 67

Array nach dem Lesevorgang:

65 66 67 0 0 0 0 0 0 0

Daraus ein erzeugter String:

'A' 'B' 'C' 0 0 0 0 0 0 0


Da der Lesende nicht weiß, wie viele Daten ankommen kannst du die Länge mitübertragen, eine bestimmte Anzahl von Zeichen lesen, bis zu einen bestimmten Zeichen lesen oder dich direkt auf ein bestimmtes Protokoll einigen.

Der BufferedReader übernimmt das "Bis zu einen bestimmten Zeichen lesen" für einen.

 

[käsekuchen]

So habe jetzt mein Programm erweitert und umgeschrieben. Vom Server zum Client kann ich super senden, nur andersrum leider nicht. Fehlermeldung anfangs:

java.lang.NullPointerException
	at server.WorkerThread.run(Server.java:102)

später, wenn ich was schicken will nur noch

java.lang.NullPointerException

Server:

package server;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Server extends JFrame {

    private JTextField tf;
    private JButton button;
    private static final int SERVER_PORT = 10001;
    private static ArrayList<ClientServer> arrl = new ArrayList();
    private static int clientCounter = -1;

    public Server() {
        this.setTitle("Server");
        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setResizable(false);
        this.setLocationRelativeTo(null);

        tf = new JTextField("name");
        button = new JButton("send");
        button.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent action) {
                for (int i = 0; i < arrl.size(); i++) {
                    arrl.get(i).send(tf.getText());
                }
            }
        });

        JPanel container = new JPanel(new FlowLayout());
        container.add(tf);
        container.add(button);
        this.add(container);
        this.setVisible(true);
    }

    public static void main(String[] args) {
        new Server();
        try {
            ServerSocket socket = new ServerSocket(SERVER_PORT);
            while (true) {
                Socket new_socket = socket.accept();
                clientCounter++;
                arrl.add(new ClientServer(new_socket));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static synchronized void print(String nachricht) {
        System.out.println(nachricht);
    }
}

class ClientServer {

    private Socket socket;
    private WorkerThread w;

    public ClientServer(Socket socket) {
        this.socket = socket;
        this.w = new WorkerThread(socket);
        w.start();
    }

    public void send(String s) {
        try {
            OutputStream output = socket.getOutputStream();
            byte[] antwort = (s).getBytes();
            output.write(antwort);
        } catch (Exception e) {
        }
    }
}

class WorkerThread extends Thread {

    private Socket socket;

    public WorkerThread(Socket s) {
        this.socket = socket;
    }

    public void run() {
        while (true) {
            try {
                byte[] b = new byte[128];
                InputStream input = socket.getInputStream();
                while (input.available() == 0);
                input.read(b);
                String in = new String(b);
                System.out.println(in);

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

Client:

package client;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.*;
import java.io.*;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Client extends JFrame{
    
    private JTextField tf;
    private JButton button;

    public static final int SERVER_PORT = 10001;
    public static final String SERVER_HOSTNAME = "localhost";
    private Socket socket;
    private ArrayList<String> arrl = new ArrayList();
    private WorkerThread w;

    public Client() {
        
        this.setTitle("Client");
        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setResizable(false);
        this.setLocationRelativeTo(null);

        tf = new JTextField("name");
        button = new JButton("send");
        button.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent action) {
                for (int i = 0; i < arrl.size(); i++) {
                    send(tf.getText());
                }
            }
        });
        
        JPanel container = new JPanel(new FlowLayout());
        container.add(tf);
        container.add(button);
        this.add(container);
        this.setVisible(true);
        
        try {
            socket = new Socket(SERVER_HOSTNAME, SERVER_PORT);
        } catch (Exception e) {
        }
        this.w = new WorkerThread(socket);
        w.start();
        
        
        
    }

    public void send(String s) {
        try {
            socket.getOutputStream().write(s.getBytes());
        } catch (Exception e) {
        }
    }

    public static void main(String[] args) {
        new Client();
    }
}

class WorkerThread extends Thread {

    private Socket socket;

    public WorkerThread(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        while (true) {
            try {
                byte[] b = new byte[128];
                InputStream input = socket.getInputStream();

                while (input.available() == 0);

                input.read(b);
                String in = new String(b);
                System.out.println(in);

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

Wüsste gerne, was nicht funktioniert. Der Fehler liegt ja anscheinend in der Klasse WorkerThread. Und ich habe auch dieses hier

while (input.available() == 0);

wieder eingebaut, heißt der wartet doch so lange bis etwas ankommt und warum kann er das dann nicht lesen? Und warum gibts schon eine Fehlermeldung bevor überhaupt was geschickt wurde?

Hoffe ihr könnt mir noch ein mal helfen!

Grüße

 

[Volvagia]

Die Zeile ist falsch.

this.socket = socket;

 

[käsekuchen]

Aber ich muss den doch übergeben oder nicht? Oder muss ein neuer erstellt werden?
Ich dachte senden und empfangen über den gleichen. und pro client ein socket?

 

[Volvagia]

Aber du speicherst nichts. Du schreibst die Socket-Variable die sowieso null ist in die selbe Socket-Variable. Und null + null ergibt leider nicht != null. :joke:

 

[käsekuchen]

Ach

this.socket = s;
ich dachte ich hätte die socket genannt ^^.

Naja jetzt kommt trotzdem nichts an.

 

[käsekuchen]

fehler gefunden.

send(tf.getText()); muss in die actionPerformed beim clienten. ausversehen die for schleife mitkopiert!

danke auf jeden fall und grüße!

 

[käsekuchen]

Mal eine Frage.

Ich habe das beim client im workerthread jetzt so gemacht, dass ein boolean namens read so lange true ist bis eine 0 geschickt wird und dann auf false.

Warum funktioniert das hier:

while(w.read){
            System.out.print("");
        }
        createDialog(w.arrl);

und das hier nicht:

while(w.read);
createDialog(w.arrl);

wenn ich das richtig verstanden habe gestern, müsste das programm doch so lange in der while-schleife hängen, bis read nicht mehr erfüllt ist. Genauso wie beim 1. code, der funktionoiert.

Warum klappt es nicht so? So wie es funktioniert sieht es nämlich nicht sehr elegant aus! Achso und dass klappt auch nicht wenn da nicht system.out.print(""); drin steht! Die schleife müsste doch trotzdem ausgeführt werden oder nicht?

Grüße

 

[AmunRa]

was bedeutet funktioniert nicht?

hast du eine Fehlermeldung?