# Streamübertragung im Server/Client



## tweek (30. Jun 2008)

Hallo!

Ich habe gerade das Kapitel über Socket Programmierung im "Java ist auch eine Insel" Buch durchgelesen und mir ist zu Listing 17.12 bzw 17.13 eine Frage eingefallen:
http://www.galileocomputing.de/open...17_008.htm#mjc7c924f6c9dc8e6d8721a70b17b2b73a

Multiplikations-Server:

```
package com.tutego.insel.net; 
 
import java.io.*; 
import java.net.*; 
 
public class MulServer 
{ 
  private static void handleConnection( Socket client ) throws IOException 
  { 
    InputStream  in  = client.getInputStream(); 
    OutputStream out = client.getOutputStream(); 
 
    int factor1 = in.read(); 
    int factor2 = in.read(); 
 
    out.write( factor1 * factor2 ); 
  } 
 
  public static void main( String[] args ) throws IOException 
  { 
    ServerSocket server = new ServerSocket( 3141 ); 
 
    while ( true ) 
    { 
      Socket client = null; 
 
      try 
      { 
        client = server.accept(); 
        handleConnection ( client ); 
      } 
      catch ( IOException e ) { 
        e.printStackTrace(); 
      } 
      finally { 
        if ( client != null ) 
          try { client.close(); } catch ( IOException e ) { } 
      } 
    } 
  } 
}
```

Multiplikations-Client:

```
package com.tutego.insel.net; 
 
import java.net.*; 
import java.io.*; 
 
class MulClient 
{ 
  public static void main( String[] args ) 
  { 
    Socket server = null; 
 
    try 
    { 
      server = new Socket( "localhost", 3141 ); 
      InputStream  in  = server.getInputStream(); 
      OutputStream out = server.getOutputStream(); 
 
      out.write( 4 ); 
      out.write( 9 ); 
      int result = in.read(); 
      System.out.println( result ); 
    } 
    catch ( UnknownHostException e ) { 
      e.printStackTrace(); 
    } 
    catch ( IOException e ) { 
      e.printStackTrace(); 
    } 
    finally 
    { 
      if ( server != null ) 
 
 
        try { server.close(); } catch ( IOException e ) { } 
    } 
  } 
}
```

Was wenn der Multiplikations-Client die Ausgabe - also die zu multiplizierenden Zahlen - mittels out.write() sendet, *bevor* der Server den In- und OutputStream initialisert hat (getInputStream(), getOutputStream() ). So gesehen hört der Server dann noch nicht mittels in.read(), während der Client schon mit out.write() sendet...

Stimmt das oder wird das im Stream evtl. gespeichert und sobald in.read() im Server aufgerufen wird, stehen die bereits gesendeten Daten im Nachhinein zur Verfügung?

Wäre nett wenn jemand dazu ein paar Worte schreiben könnte!

Vielen Dank schon mal!


Gruß,
manuel[/code]


----------



## SlaterB (30. Jun 2008)

> bevor der Server den In- und OutputStream initialisert hat (getInputStream(), getOutputStream() )

mit den get-Aufrufen kannst du nur auf diese Streams zugreifen,
die sind aber schon lange da

die Daten warten allerdings evtl. im Cache der Netzwerkkarte oder des verwaltenden Betriebssystem,
wieviel passt da rein? 8 kb rate ich spontan, danach werden weitere Netz-Pakete abgeleht,

erst bei einem read()-Aufruf werden die Daten von irgendwoher außerhalb Java geladen
(Achtung: teils Vermutung/ dunkle Erinnerung)


----------



## tweek (30. Jun 2008)

Hmm... ok, dass die Streams schon existieren hätte ich eigentlich auch wissen müssen...

Also wenn jetzt out.write() vor in.read() aufgerufen wird:
Normalerweise blockiert in.read() ja die ausführung und horcht ob was reinkommt... wenn aber das "Reinkommen" vor dem Horchen stattfindet... was passiert dann?

Funktioniert das in Java?


----------



## SlaterB (30. Jun 2008)

wenn nix da ist, wird gewartet, 
wenn schon was da ist (kommt wie gesagt erst in diesem Moment aus dem Netzwerk-Cache) dann gehts direkt weiter


----------



## Guest (30. Jun 2008)

ok, und wenn der cache voll is - pech gehabt... 

Danke!


----------



## tuxedo (30. Jun 2008)

Wenn der Buffer sowohl auf Sende als auch auf Empfangsseite voll ist wartet sich das ganze vermutlich solange zu tode, bis auf Empfangsseite der Puffer geleert wird. Intern wird der Client wohl immer wieder versuchem dem Server was zu schicken, der wird aber im Antwortpaket mitteilen, dass er nix mehr aufnehmen kann. Und so wirds der Client eben immer wieder mal probieren, solange bis der Server (bzw. das OS) mit einem "alles klar, her damit" antwortet. Und das wird er erst antworten, wenn wieder Platz im Empfangspuffer ist.

Mit TCP gehen jedenfalls (normalerweise) keine Pakete verloren.


----------

