SocketException: Socket closed

IDC · 5. Oktober 2013 um 11:02

Hallo

Ich hab erst vor etwa einer Stunde mit Socket’s und derartigem angefangen und stehe jetzt vor einem Problem an dem ich scheitere…

Hab mir aus einem Tutorial diesen (schon größtenteils eigenen) Code zusammengesucht:

Server:


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayList;

public class ServerTest {
    ServerSocket serverSocket = null;
    ArrayList<ClientThread> clients = new ArrayList<>();
    public static void main(String[] args) {
        new ServerTest(3443);
    }

    public void sendMsgToAll(String s) {
        for (ClientThread ct: clients) {
            try {
                ct.sendToClient(s);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public ServerTest(int port) {
        try {
            serverSocket = new ServerSocket(port);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        Thread checkForNewClients = new Thread(new Runnable() {
            @Override
            public void run() {
                Socket newClientConnection = null;
                while (true) {
                    System.out.println("wait for new Client's");
                    try {
                        newClientConnection = serverSocket.accept();
                        ClientThread ct = new ClientThread(newClientConnection);
                        ct.start();
                        clients.add(ct);
                    } catch (SocketException ex) {
                        ex.printStackTrace();
                    } catch (UnknownHostException ex) {
                        ex.printStackTrace();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    } finally {
                       if ( newClientConnection != null )
                         try { newClientConnection.close(); } catch ( IOException e ) { }
                     }
                }
            }
        });
        checkForNewClients.start();
//        catch (InterruptedException ex) {
//            ex.printStackTrace();
//        }
    }

     private class ClientThread extends Thread {
         String idName;
         Socket clientConnection;
         DataInputStream inputStream;
         DataOutputStream outputStream;

         public ClientThread(Socket clientConn) {
             clientConnection = clientConn;
             try {
                 inputStream = new DataInputStream(new 
                             BufferedInputStream(clientConnection.getInputStream()));
                 outputStream = new DataOutputStream(new
                             BufferedOutputStream(clientConnection.getOutputStream()));
             } catch (IOException ex) {
             }
         }

         public void sendToClient(String s) throws IOException {
             outputStream.writeChars(s);
         }
         
         @Override
         public void run() {
             while(true) {
                 try {
                     String s = inputStream.readUTF();
                     System.out.println(s);
                     sendMsgToAll(s);
                 } catch (IOException ex) {
                     ex.printStackTrace();
                 }
             }
         }
     }
}

Client:


import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class ClientTest {
   private DataOutputStream streamOut = null;

    long counter = 0;
    public static void main(String[] args) {
        new ClientTest(3443);
    }

    public ClientTest(int port) {
        Socket serverConnection = null;
        try {
            SocketAddress addr = new InetSocketAddress( "localhost", 3443 );
            serverConnection = new Socket();
            serverConnection.connect( addr, 100 );
            streamOut = new DataOutputStream(serverConnection.getOutputStream());
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            counter += System.nanoTime();
                            if (counter > 10000000) {
                                counter = 0;
                                streamOut.writeUTF("i:");
                            }
                            Thread.sleep(1);
                        } catch(Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                }
                
            });
            t.start();
        } catch (SocketException ex) {
            ex.printStackTrace();
        } catch (UnknownHostException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                serverConnection.close();
            } catch (IOException ex) {
            }
        }
    }
}

Aus irgendeinem Grund(der mir als Socket Anfänger nicht auffällt) kommt diese Ausgabe:

Server:


wait for new Client's
wait for new Client's
//Und dann in Endlosschleife:
java.net.SocketException: socket closed
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.read(SocketInputStream.java:150)
	at java.net.SocketInputStream.read(SocketInputStream.java:121)
	at java.io.BufferedInputStream.fill(BufferedInputStream.java:235)
	at java.io.BufferedInputStream.read(BufferedInputStream.java:254)
	at java.io.DataInputStream.readUnsignedShort(DataInputStream.java:337)
	at java.io.DataInputStream.readUTF(DataInputStream.java:589)
	at java.io.DataInputStream.readUTF(DataInputStream.java:564)
	at badTestings.socketTests.ServerTest$ClientThread.run(ServerTest.java:99)

Client:


//In Endlosschleife:
java.net.SocketException: socket closed
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.read(SocketInputStream.java:150)
	at java.net.SocketInputStream.read(SocketInputStream.java:121)
	at java.io.BufferedInputStream.fill(BufferedInputStream.java:235)
	at java.io.BufferedInputStream.read(BufferedInputStream.java:254)
	at java.io.DataInputStream.readUnsignedShort(DataInputStream.java:337)
	at java.io.DataInputStream.readUTF(DataInputStream.java:589)
	at java.io.DataInputStream.readUTF(DataInputStream.java:564)
	at badTestings.socketTests.ServerTest$ClientThread.run(ServerTest.java:99)

Wäre ultra freundlich wenn sich jemand den Code mal angucken könnte! Ich stehe nämlich völlig auf dem Schlauch!!!
:verzweifel: :verzweifel: :verzweifel:
:wein:

SlaterB · 5. Oktober 2013 um 11:10

wenn der Server, der checkForNewClients-Thread, eine Verbindung akzeptiert, gibt er diese an einen Thread dafür ab,
Millesekunden später ist er im finally und schließt die Verbindung,

das kann es ja nicht sein, der checkForNewClients-Thread darf die Verbindung nicht schließen,
dass muss er dem Thread für diese Verbindung überlassen, z.B. am Ende von dessen run()-Methode

beim Client ähnliches Problem

übrigens ist die main-Methode selber ein Thread,
wenn dort nichts anderes an Code kommt, dann könnte der main-Thread ja auch irgendwas machen,

der checkForNewClients-Thread beim Server ist unnötig,
beim Client ist der eine Thread t im Moment auch unnötig,
aber schadet beides auch nicht viel, nur Code etwas unübersichtlich

IDC · 5. Oktober 2013 um 11:33

Vielen Dank schon mal,

jetzt hat der Server seine endlos Exception geändert:


java.io.EOFException
	at java.io.DataInputStream.readUnsignedShort(DataInputStream.java:340)
	at java.io.DataInputStream.readUTF(DataInputStream.java:589)
	at java.io.DataInputStream.readUTF(DataInputStream.java:564)
	at socketTests.ServerTest$ClientThread.run(ServerTest.java:89)

Was hat das nun zu bedeuten?

SlaterB · 5. Oktober 2013 um 12:39

schließt der Client nun den Socket recht zügig?

ich habe ein Testprogramm ohne jedes close zusammengebaut (langfristig natürlich keine Lösung, aber ein laufender Anfang),
eine main startet Server + Client (hier bringen deine extra-Threads Vorteile)

Code ein wenig geändert, alle 0.6 sec wird eine sich erhöhende Zahl gesendet

Ausgabe:


wait for new Client's
wait for new Client's
i:1
i:2
i:3
i:4
i:5
i:6
i:7
...

public class Test {

	public static void main(String[] args) throws Exception {
		new ServerTest2(3443);
		Thread.sleep(400);
		new ClientTest2(3443);
	}
}

class ServerTest2 {
	ServerSocket serverSocket = null;
	ArrayList<ClientThread> clients = new ArrayList<ClientThread>();

	public void sendMsgToAll(String s) {
		for (ClientThread ct : clients) {
			try {
				ct.sendToClient(s);
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
	}

	public ServerTest2(int port) {
		try {
			serverSocket = new ServerSocket(port);
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		Thread checkForNewClients = new Thread(new Runnable() {
			@Override
			public void run() {
				Socket newClientConnection = null;
				while (true) {
					System.out.println("wait for new Client's");
					try {
						newClientConnection = serverSocket.accept();
						ClientThread ct = new ClientThread(newClientConnection);
						ct.start();
						clients.add(ct);
					} catch (Exception ex) {
						ex.printStackTrace();
					}
				}
			}
		});
		checkForNewClients.start();
	}

	private class ClientThread extends Thread {
		String idName;
		Socket clientConnection;
		DataInputStream inputStream;
		DataOutputStream outputStream;

		public ClientThread(Socket clientConn) {
			clientConnection = clientConn;
			try {
				inputStream = new DataInputStream(new BufferedInputStream(
						clientConnection.getInputStream()));
				outputStream = new DataOutputStream(new BufferedOutputStream(
						clientConnection.getOutputStream()));
			} catch (IOException ex) {
			}
		}

		public void sendToClient(String s) throws IOException {
			outputStream.writeChars(s);
		}

		@Override
		public void run() {
			while (true) {
				try {
					String s = inputStream.readUTF();
					System.out.println(s);
					sendMsgToAll(s);
				} catch (IOException ex) {
					ex.printStackTrace();
				}
			}
		}
	}
}

class ClientTest2 {
	private DataOutputStream streamOut = null;

	long counter = 0;

	public ClientTest2(int port) {
		Socket serverConnection = null;
		try {
			SocketAddress addr = new InetSocketAddress("localhost", 3443);
			serverConnection = new Socket();
			serverConnection.connect(addr, 100);
			streamOut = new DataOutputStream(serverConnection.getOutputStream());
			Thread t = new Thread(new Runnable() {
				@Override
				public void run() {
					while (true) {
						try {
							counter++;
							streamOut.writeUTF("i:" + counter);
							Thread.sleep(600);
						} catch (Exception ex) {
							ex.printStackTrace();
						}
					}
				}

			});
			t.start();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

IDC · 5. Oktober 2013 um 12:57

Ahh, danke der Code funktioniert, aber was genau hast du geändert?
Ich sehe nur den teil im Thread der ClientTest2 und wahrscheinlich den Wald vor lauter Bäumen nicht…

SlaterB · 5. Oktober 2013 um 16:58

was ich geändert habe siehst du im Vergleich,
was genau bei dir schief geht, kann ich nicht sagen ohne neuen Code

IDC · 6. Oktober 2013 um 01:21

Ok, du hast also das finally am Ende des Client Thread’s auch noch entfernt…
Gut, aber korrigier mich:
Finnally wird doch erst am Ende oder wenn eine Exception aufgerufen wird ausgelöst…

EDIT: verdammt mein Thread hat mir hier wohl ein Bein gestellt

Danke!!
Ich poste hier vielleicht noch mein Endergebnis, wenn es nicht zu stümperhaft ist :crowd:

SlaterB · 6. Oktober 2013 um 03:36

wie gesagt war beim Server + Client im ersten Posting die Situation gleich, in beiden wurde sofort geschlossen,
es wird nicht gewartet, bis der gestartete Thread zu Ende ist, das widerspricht ja auch dem Sinn des Starten eines Threads

IDC · 6. Oktober 2013 um 06:25

So hab mir jetzt ein kleines Test-Chat Programm(mit test GUI) zusammengebastelt:

Client-GUI:


import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

public class TEST_ClientGUI {
    JFrame frame = new JFrame("Client");
        JPanel startClientPanel = new JPanel();
            JTextField inputIP = new JTextField(12);
            JTextField inputPort = new JTextField(6);
        JTextArea output_Display = new JTextArea();
            JScrollPane output_Display_Sroller = new JScrollPane(output_Display);
        JTextField sendToServer = new JTextField();

    Client client = new Client();

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

    public TEST_ClientGUI() {
        frame.setSize(400,300);
        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        frame.addWindowListener(new WindowListener() {
            @Override public void windowOpened(WindowEvent e) {}
            @Override public void windowClosed(WindowEvent e) {}
            @Override public void windowIconified(WindowEvent e) {}
            @Override public void windowDeiconified(WindowEvent e) {}
            @Override public void windowActivated(WindowEvent e) {}
            @Override public void windowDeactivated(WindowEvent e) {}

            @Override
            public void windowClosing(WindowEvent e) {
                client.stopConnection();
                System.exit(0);
            }
        });

        frame.add(output_Display_Sroller, BorderLayout.CENTER);
        client.newMsgL = new NewMessageListener() {
            @Override
            public void printToGUI(String msg) {
                output_Display.append(msg+"
");
                output_Display_Sroller.getVerticalScrollBar().setValue(output_Display.getHeight());
            }
        };
        output_Display.setEnabled(false);
        output_Display.setBackground(Color.black);

        frame.add(startClientPanel, BorderLayout.NORTH);
        startClientPanel.add(inputPort);
        inputPort.setDocument(new PlainDocument() {
            int largestInt = 65535;

            @Override
            public void insertString(int offs, String str, AttributeSet a) throws BadLocationException {
                if (str.equals("port")) {
                } else {
                    try {
                        Integer.parseInt(str);
                    } catch (NumberFormatException e) {
                        Toolkit.getDefaultToolkit().beep();
                        return;
                    }
                    int i = Integer.parseInt(inputPort.getText()+str);
                    if (i > largestInt) {
                        Toolkit.getDefaultToolkit().beep();
                        return;
                    }
                }
                super.insertString(offs, str, a);
            }
        });
        inputPort.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                if (inputPort.getText().equals("port"))
                    inputPort.setText("");
            }

            @Override
            public void focusLost(FocusEvent e) {
                if (inputPort.getText().equals(""))
                    inputPort.setText("3443");
            }
        });
        inputPort.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int port = 3443;
                if (! inputPort.getText().equals("") && Integer.parseInt(inputPort.getText()) >= 1024)
                    port = Integer.parseInt(inputPort.getText());

                client.initConnection(inputIP.getText(), port);
            }
        });
        inputPort.setText("port");

        startClientPanel.add(inputIP);
        inputIP.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                if (inputIP.getText().equals("ip"))
                    inputIP.setText("");
            }

            @Override
            public void focusLost(FocusEvent e) {
                if (inputIP.getText().equals(""))
                    inputIP.setText("localhost");
            }
        });
        inputIP.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                client.initConnection(inputIP.getText(), Integer.parseInt(inputPort.getText()));
            }
        });
        inputIP.setText("ip");

        frame.add(sendToServer, BorderLayout.SOUTH);
        sendToServer.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                client.sendToServer(sendToServer.getText());
            }
        });

        frame.repaint();
    }
}```

Client:
```package badTestings.socketTests;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class Client {
   private Socket serverConnection = null;
   private DataOutputStream streamOut = null;
   private DataInputStream streamIn = null;
   MainClientThread mClT;
        private boolean run_Thread_run = false;

    NewMessageListener newMsgL = null;

    public void stopConnection() {
        System.out.println("stopConnection()");
        run_Thread_run = false;
        try {
            if (serverConnection != null) {
                serverConnection.close();
                newMsgL.printToGUI("serverConnection CLOSED");
            }
        } catch (IOException ex) {
            newMsgL.printToGUI("can't close Socket: " + ex.getMessage());
        }
        serverConnection = null;
    }

    public void initConnection(String serverIP, int port) {
        if (serverConnection != null)
            stopConnection();
        try {
            newMsgL.printToGUI("Tries to init new Connection(ip: "+serverIP+" port:"+port+")");
            SocketAddress addr = new InetSocketAddress( serverIP,port );
            serverConnection = new Socket();
            serverConnection.connect( addr, 100 );
            streamOut = new DataOutputStream(serverConnection.getOutputStream());
            streamIn = new DataInputStream(serverConnection.getInputStream());

            Thread.sleep(100);

            run_Thread_run = true;
            mClT = new MainClientThread();
            mClT.start();
            newMsgL.printToGUI("serverConnection closed: "+serverConnection.isClosed());
            newMsgL.printToGUI("run_Thread_run"+run_Thread_run);
            newMsgL.printToGUI("Connection established!");
        } catch (SocketException ex) {
            newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
        } catch (UnknownHostException ex) {
            newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
        } catch (IOException ex) {
            newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
        } catch (InterruptedException ex) {
            newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
        }
    }

    public void sendToServer(String s) {
        try {
            streamOut.writeUTF(s);
            newMsgL.printToGUI("Message("+s+") send to Server!");
        } catch(Exception ex) {
            newMsgL.printToGUI("can't send Message("+s+") to Server: "+ex.getMessage());
        }
            newMsgL.printToGUI("serverConnection closed: "+serverConnection.isClosed());
            newMsgL.printToGUI("run_Thread_run"+run_Thread_run);
    }

    private class MainClientThread extends Thread {
        @Override
        public void run() {
            while (run_Thread_run) {
                try {
                    if (! serverConnection.isClosed() && streamIn.available() > 0) {
                        newMsgL.printToGUI("Recieved from Server: "+streamIn.readUTF());
                    }
                } catch(Exception ex) {
                    newMsgL.printToGUI("Failed to read from Server: "+ex.getMessage());
                }
            }
                System.out.println("client Main ended: "+run_Thread_run);
        }
    }
}```





Server-GUI:
```package badTestings.socketTests;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

public class ServerGUI {
    JFrame frame = new JFrame("Server");
        JPanel startServerPanel = new JPanel();
            JTextField inputPort = new JTextField(6);
        JTextArea output_Display = new JTextArea();
            JScrollPane output_Display_Sroller = new JScrollPane(output_Display);

    Server server = new Server();

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

    public ServerGUI() {
        frame.setSize(400,300);
        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        frame.addWindowListener(new WindowListener() {
            @Override public void windowOpened(WindowEvent e) {}
            @Override public void windowClosed(WindowEvent e) {}
            @Override public void windowIconified(WindowEvent e) {}
            @Override public void windowDeiconified(WindowEvent e) {}
            @Override public void windowActivated(WindowEvent e) {}
            @Override public void windowDeactivated(WindowEvent e) {}

            @Override
            public void windowClosing(WindowEvent e) {
                server.killServer();
                System.exit(0);
            }
        });

        frame.add(output_Display_Sroller, BorderLayout.CENTER);
        server.newMsgL = new NewMessageListener() {
            @Override
            public void printToGUI(String msg) {
                output_Display.append(msg+"
");
                output_Display_Sroller.getVerticalScrollBar().setValue(output_Display.getHeight());
            }
        };
        output_Display.setEnabled(false);
        output_Display.setBackground(Color.black);

        frame.add(startServerPanel, BorderLayout.NORTH);
        startServerPanel.add(inputPort);
        inputPort.setDocument(new PlainDocument() {
            int largestInt = 65535;

            @Override
            public void insertString(int offs, String str, AttributeSet a) throws BadLocationException {
                if (str.equals("port")) {
                } else {
                    try {
                        Integer.parseInt(str);
                    } catch (NumberFormatException e) {
                        Toolkit.getDefaultToolkit().beep();
                        return;
                    }
                    int i = Integer.parseInt(inputPort.getText()+str);
                    if (i > largestInt) {
                        Toolkit.getDefaultToolkit().beep();
                        return;
                    }
                }
                super.insertString(offs, str, a);
            }
        });
        inputPort.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                if (inputPort.getText().equals("port"))
                    inputPort.setText("");
            }

            @Override
            public void focusLost(FocusEvent e) {
                if (inputPort.getText().equals(""))
                    inputPort.setText("3443");
            }
        });
        inputPort.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int port = 3443;
                if (! inputPort.getText().equals("") && Integer.parseInt(inputPort.getText()) >= 1024)
                    port = Integer.parseInt(inputPort.getText());

                server.startServer(port);
            }
        });
        inputPort.setText("port");

        frame.repaint();
    }
}```

Sever:
```package badTestings.socketTests;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayList;

public class Server {
    private ServerSocket serverSocket = null;
    MainServerThread checkForNewClients;
        boolean run_Thread_run = false;
    private ArrayList<ClientThread> clients = new ArrayList<>();

    NewMessageListener newMsgL = null;

    public void killServer() {
        run_Thread_run = false;
        try {
            if (serverSocket != null)
                serverSocket.close();
        } catch (IOException ex) {
            newMsgL.printToGUI("Can't kill Server: "+ex.getMessage());
        }
        for (ClientThread ct: clients) {
            ct.close();
        }
        clients.clear();
        serverSocket = null;
    }

    public void startServer(int port) {
        if (serverSocket != null || clients.size() != 0) {
            killServer();
            newMsgL.printToGUI("Old Server Killed");
        }

        try {
            serverSocket = new ServerSocket(port);
            newMsgL.printToGUI("New Server Socket(port: "+port+") initiated");
        } catch (IOException ex) {
            newMsgL.printToGUI("can't init new ServerSocket(with port: "+port+"): " + ex.getMessage());
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException ex) {}
        run_Thread_run = true;
        checkForNewClients = new MainServerThread();
        checkForNewClients.start();
    }

    private void killClient(ClientThread ct) {
        ct.close();
        clients.remove(ct);
        newMsgL.printToGUI("Client("+ct.idName+") disconnected...");
    }

    public void sendMsgToAll(String s) {
//        newMsgL.printToGUI("Tries to send Message("+s+") to all Clients");
        for (ClientThread ct: clients) {
            try {
                ct.sendToClient(s);
//                newMsgL.printToGUI("Message("+s+") send to Client: "+ct.idName);
            } catch (IOException ex) {
                newMsgL.printToGUI("Failed to send Message("+s+") at Client: "+ct.idName);
                newMsgL.printToGUI("Disconnecting Client: "+ct.idName);
                killClient(ct);
            }
        }
        newMsgL.printToGUI("Message("+s+") send to Clients");
    }


     private class MainServerThread extends Thread {
        @Override
        public void run() {
            Socket newClientConnection = null;
            while (run_Thread_run) {
                ClientThread ct = null;
                try {
                    newMsgL.printToGUI("Server Waiting for new Client's...");
                    if (serverSocket != null && ! serverSocket.isClosed())
                        newClientConnection = serverSocket.accept();
                    newMsgL.printToGUI("New Client tries to connect: " + newClientConnection);
                    ct = new ClientThread(newClientConnection);
                } catch (SocketException ex) {
                    newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
                    continue;
                } catch (UnknownHostException ex) {
                    newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
                    continue;
                } catch (IOException ex) {
                    newMsgL.printToGUI("can't init new Socket: " + ex.getMessage());
                    continue;
                }
                ct.start();
                clients.add(ct);
                newMsgL.printToGUI("New Client connected!");
            }
        }
     }


     private class ClientThread extends Thread {
         String idName;
         Socket clientConnection;
         DataInputStream inputStream;
         DataOutputStream outputStream;

         public ClientThread(Socket clientConn) throws IOException {
             clientConnection = clientConn;
             inputStream = new DataInputStream(new 
                        BufferedInputStream(clientConnection.getInputStream()));
             outputStream = new DataOutputStream(new
                        BufferedOutputStream(clientConnection.getOutputStream()));
         }

         public void sendToClient(String s) throws IOException {
             outputStream.writeUTF(s);
         }

         @Override
         public void run() {
             while(true) {
                 try {
                     if (! clientConnection.isClosed()) {
                        String s = inputStream.readUTF();
                        sendMsgToAll(s);
                     }
                 } catch (IOException ex) {
                     killClient(this);
                 }
             }
         }

         public void close() {
             try {
                 clientConnection.close();
                 inputStream.close();
                 outputStream.close();
             } catch (IOException ex) {
                 ex.printStackTrace();
             }
         }
     }
}```

Client to Server---Check
Zurück von Server zu Client---Toolkit.getDefaultToolkit().beep();

Es gibt keine Exception dieses Mal :suspect:
Allerdings auffällig ist das der Server zwar ohne Exception sendet, beim Client allerdings der inputStream constant available() == 0 hat!!!

Ich stehe hier mal wieder auf dem Schlauch, wäre sehr nett wenn mir hier jemand helfen könnte!!!!

Edit:
 @SlaterB : Ich frag auch nicht wieder so dumm nach versprochen ;)

SlaterB · 6. Oktober 2013 um 12:05

puh, warum so viel,
evtl. schaue ich es mir noch an, Erinnerung dass noch aktuell dürfte helfen,
lieber wäre mir aber eine Form wie in meinem Posting:

nur ein public-Klasse mit Test, der Rest interne Klassen, alles in einem Code-Block,
main-Methode startet Server, etwas Pause, startet Client, ob GUI oder nicht dürfte nicht so relevant sein, siehe nächster Schritt
automatisches Senden usw., keine GUI-Eingaben, Programm sollte man nur kopieren, laufen lassen, bis zum Fehler

möglich dass dieser Stand schon ok ist und du speziell mit GUI noch Probleme hast

IDC · 6. Oktober 2013 um 12:32

Wäre dir sehr Dankbar wenn du dir das wenn du nochmal drüber gucken könntest…
Ich finde meinen Fehler einfach nicht ;(

IDC · 7. Oktober 2013 um 00:52

outputStream = new DataOutputStream(new BufferedOutputStream(clientConnection.getOutputStream()));
:dontwork::dontwork::dontwork::dontwork::dontwork:

outputStream = new DataOutputStream(clientConnection.getOutputStream());
Funktioniert!
:laola::crowd:

Und ich verstehe nicht wieso!! Hast du eine Idee?

SlaterB · 7. Oktober 2013 um 00:57

ein Buffer buffert, das ist seine Grundfunktion, sendet nicht sofort, sondern erst wenn z.B. 8192 Bytes zusammenkommen,
flush() kann das Senden erzwingen, Standard-Befehl in diesem Bereich

(sinnvoll wäre auch, nach einer gewissen Zeit zu senden, maximal einmal pro Sekunde während zig kleine Kommandos pro Sekunde ankommen,
hier nicht der Fall, nur Steuerung über Anzahl Bytes)

ein einfaches 10 Zeile-Programm kann sowas testen, viele Klassen mit viel unnötigen Code verschleiern es nur,
irgendwann wäre ich aber auch dazu gekommen

IDC · 7. Oktober 2013 um 02:42

[QUOTE=SlaterB]
ein einfaches 10 Zeile-Programm kann sowas testen, viele Klassen mit viel unnötigen Code verschleiern es nur,
irgendwann wäre ich aber auch dazu gekommen[/QUOTE]
Ich habe es auch nur im direkten Vergleich bemerkt…
Naja ich habe jetzt die Output und InputStream’s in ObjectOutput und ObjectInputStream’s geändert und schon EOFException beim zurücksenden! Fällt dir da spontan ein Grund ein?
Ich mach erstmal mein Test-Programm mit dem String hin und her senden fertig, aber ich möchte später auch Objekte senden!!! Nur ein erster Test lieferte halt das…
Beim hin und zurücksenden(es wurden weiter Strings gesendet nur eben über die Methode writeObject(…); ) kam dieselbe Ausgabe, nur beim berüchtigen Server to Client senden kam wieder dieser Fehler!

SlaterB · 7. Oktober 2013 um 02:50

EOFException klingt naturgemäß genauso wie schon Posting #3, kann wieder eine Frage von zu frühen Schließen auf einer Seite sein,
wenn mir nicht davon abgeraten wäre, dich für so ‚dumm‘ zu halten, das wieder zu machen

vielleicht passen die Streams auch nicht zusammen, auf einer Seite ObjectInputStream,
auf der anderen nicht ObjectOutputStream sondern ein anderer,
nach deinem Posting eigentlich auch ausgeschlossen

es hilft nur Code

IDC · 7. Oktober 2013 um 03:47

[QUOTE=SlaterB]
es hilft nur Code[/QUOTE]
Ja, oder nachdenken auch hier war wieder flush(); nötig…
Ich glaub ich mach den Fehler noch 3 Mal und dann hör ich auf