ClientServer mit 2 Threads

[leaves]

Hey,

wir möchten einen ClientServer mittels Socket programmieren.
Die Verbindung mit einem Client funktioniert ohne Probleme.
Sobald wir einen zweiten Client dazunehmen, funktioniert der Nachrichtenaustausch nicht mehr, bzw. der Text kommt nicht bei allen Clients an.

Wir vermuten das man beim Socket-Prinzip nicht zwei BufferedReader verwenden kann?

public void run() {
				
				BufferedReader in = null;
				while( null == serverSocket) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
				}
				try{
					in = new BufferedReader(new 
							InputStreamReader(serverSocket.getInputStream()));
					while(_doRun) {
						while( null != (line = in.readLine())){
							if ("logged off".equals(line)) {
								_doRun = false;
								System.out.println(line);
								//Abmelden
							}
							System.out.println(line);	

//Zweiter				}

public void run(){
		PrintWriter pw = null;
		BufferedReader sysIn = null;
		try{
			this.serverSocket = new Socket("localhost", _portNumber );
			pw = new PrintWriter( serverSocket.getOutputStream(), true);
           
			String line;
			sysIn = new BufferedReader(new 
					InputStreamReader(System.in ));
			System.out.println( "Type your text or 'quit' to end:" );
			while( null != (line = sysIn.readLine()) ) {
				.....
				}

Vielen Dank für die Hilfe

 

[DocRandom]

..ä´hm, schon mal die Forensuche bemüht?
Zu diesem Thema findest Du genug Beiträge!

lg

 

[Stefan S.]

Was ist das für ein Codefetzen? Zwei run Methoden und dazwischen auch noch ein Sleep(). Das sieht nach Unsinn aus.

Erstelle einen Server, der in einem Thread läuft, neue Klienten akzeptiert und diesen in einen neu erstelltem Thread abarbeitet. Am besten verwendest du dafür einen Threadpool.

Schau dir mal die Netzwerkbibliothek in dem folgenden Spiel an.

// Copyright: [url=http://www.codeplanet.eu/]CodePlanet: The planet of living code![/url]
public class NodeService extends Thread implements Runnable
{
    public void requestStop()
    {
        stop_ = true;
    }
 
    @Override
    public void run()
    {
        // Creates a thread pool that creates new threads as needed, but
        // will reuse previously constructed threads when they are available.
        final ExecutorService pool = Executors.newCachedThreadPool();
 
        try {
            service_ = true;
            sock = makeServerSocket( myInfo_.getPort() );
            sock.setSoTimeout( SOCKETTIMEOUT );
            while( !stop_ ) {
                try {
                    logger_.finest( "Listening..." );
                    Socket clientsock = sock.accept();
                    clientsock.setSoTimeout( 0 );
 
                    // Execute handler
                    pool.execute( new PeerHandler( clientsock ) );
 
                } catch( SocketTimeoutException e ) {
                    logger_.finer( e.getMessage() );
                    continue;
                } catch( Exception e ) {
                }
            }
            sock.close();
        } catch( SocketException e ) {
            logger_.severe( "SocketException NodeService: " + e );
        } catch( IOException e ) {
            logger_.severe( "IOException NodeService: " + e );
        } finally {
            pool.shutdown();
            service_ = false;   // We are no longer servicing
        }
    }
 
    private volatile boolean stop_ = false;
    private ServerSocket sock;
}

Es ist relativ aufwendig, einen neuen Thread zu konstruieren, da das Betriebssystem beteiligt ist. Wenn unser Programm eine große Anzahl von kurzlebigen Threads erzeugt, sollte es stattdessen einen Thread-Pool verwenden. Ein Thread-Pool enthält eine Anzahl von ausführungsbereiten Leerlauf-Threads. Man gibt Runnable an den Pool und einer der Threads ruft die Methode run auf. Wenn die Methode run endet, stirbt der Thread nicht, sondern bleibt erhalten, um die nächste Anforderung zu bedienen.

Netzwerkprogrammierung in Java - Page 4

 

[leaves]

Das íst auch nur ein Teil
Die Frage war nur ob ich bei einem Socket zwei BufferedReader benutzen kann.
Leider gibt er bei zweiten Client nur die alte Nachricht aus, bzw. null wenn noch keine geschrieben wurde.

 

[leaves]

...

 

[tuxedo]

Die Frage war nur ob ich bei einem Socket zwei BufferedReader benutzen kann.

Ein ganz klares: Selbstverständlich geht das. Du kannst auch 3 oder auch 200 benutzen wenn es notwendig ist. Etwas "spezielles" muss man hierbei eigntlich nicht beachten. D.h. dein Fehler liegt irgendwo anders.

- Alex