Sockets und Synchronisation

[sani]

Hallo allerseits!

Ich probiere zwischen zwei Systeme Dateien zu verschieben und benutze dafür die Sockets. Leider funktioniert etwas nicht ganz so, wie ich es mir vorgestellt habe. Ich denke, dass etwas mit Synchronisation nich funktioniert. Denn, wenn ich eine ZIP-Datei (Groesse ca. 400 MB) übertrage, kommt es ab und zu zu einem Durcheinander. Ich schreibe / lese mit DataOutputStream bzw. mit DataInputStream.

Hier noch der Codeauszug von beiden Seiten:

Sender:

// Dateilaenge an den Client senden
long fileLaenge = file.length();
dos.writeLong(fileLaenge);
dos.flush();

// Daten aus der Datei lesen und senden
int anzahlZeichenGelesen = fis.read(buffer);

while (anzahlZeichenGelesen != -1)
{
	dos.write(buffer, 0, anzahlZeichenGelesen);
	dos.flush();
	// Daten aus der Datei lesen
	anzahlZeichenGelesen = fis.read(buffer);
	// Warten, bis die Gegenseite fuer das naechste Datenpaket
	// bereit is. Ihre Bereitschaft wird sie durch das Senden einer
	// Null (0) signalisieren. Der Bereitschaft-Wert wird hier nicht
	// verwertet, da die Methode readInt blockierend.

	if (anzahlZeichenGelesen != -1)
	{
		// Falls nich EOF, warten auf die Gegenseite
		paketAbgeholt = dis.readInt();
	}
}

// Stream schliessen
fis.close();

Empfänger:

long fileLaenge = 0;
int paketAbgeholt = 0;

// Filegroesse auslesen
fileLaenge = dis.readLong();

// Anzahl 'voller' Buffers berechnen
long anzahlVollerBuffer = fileLaenge / BUFFERSIZE;

// Daten auslesen und in die Datei schreiben
for (long i = 0; i < anzahlVollerBuffer; i++)
{
	dis.read(buffer);

	fileOutStream.write(buffer);
	// Der Gegenseite melden, dass das naechste Datenpaket
	// gesendent werden kann. 

		// Wenn ich nach jedem Senden den Thread schlafen lege, funktioniert es! Das verzögert aber die Übertragung unheimlich stark bei einer Datei von 400 MB!!!
		// try
		// {
		// 	Thread.sleep(30);
		// }
		// catch (InterruptedException e)
		// {
		// 	mach was ...
		// }
	
	dos.writeInt(paketAbgeholt);
}

// Die uebriggebliebene Bytes lesen und in die Datei schreiben
int restBytes = (int) (fileLaenge - (anzahlVollerBuffer * BUFFERSIZE));

dis.read(buffer, 0, restBytes);
fileOutStream.write(buffer, 0, restBytes);

file = null;
fileOutStream.close();

Nun, was mache ich falsch?

 

[Guest]

Und, wie gross ist der buffer?

 

[sani]

Und, wie gross ist der buffer?

Ich arbeite zur Zeit mit 4 KB (4096) grossen Buffers. Komisch ist allerdings, dass es bei kleineren Dateien (ein paar MB) keine Probleme bei der Übertragung gibt. Nur bei den grösseren Dateien wird es problematisch. Allerdings, kann das (das es mit kleineren Dateien klappt) natürlich auch reiner Zufall sein.

 

[Guest]

Schon mit grösseren Buffers ( 32 db oder 64 kb) probiert?

 

[sani]

Ja. Leider, ändert nicht viel.

 

[Bleiglanz]

ehrlich gesagt versteh ich nicht, warum du immer die grösse rumschleppst

socket aufmachen
in den rohen inputstream alle bytes reinschreiben, evtl. mit Buffer
(wozu der DataStream??)
flushen

   dis.read(buffer);

   dos.writeInt(paketAbgeholt);

dieses hickl-hackl mit paketAbgeholt usw. ist doch völlig überflüssig und wahrscheinlich für deine Probleme verantwortlich???

 

[Guest]

dieses hickl-hackl mit paketAbgeholt usw. ist doch völlig überflüssig und wahrscheinlich für deine Probleme verantwortlich???

Mag sein, dass dies nicht nötig ist. Was passiert aber, wenn der Sender viel schneller ist als Empfänger? Könnte es sein, dass die neu angekommene Daten die nicht abgeholten Daten überschreiben? Oder, ist das so, dass in einem solchen Fall das Senden gestoppt wird, bis es auf der Empfänger Seite freien Platz (sprich: Sender hat wieder etwas abgeholt) gibt? Heisst das, dass auch bei Sockets eine gewisse Synchronisation gewährleitst ist?

Danke

 

[Bleiglanz]

write -> schreibt einfach ein byte "in den Socket"
read -> holt ein byte "aus dem Socket"

da geht keins verloren...

und mach dir keine Sorgen: wenn du nicht gerade den allllllerlangsamsten Rechner hast, dann wird das abholen von Bytes immer viel schneller gehen als "die" Ankuft übers Netzwerk

und selbst in dem total unwahrscheinlichen Fall gibts da einen Puffer (der aber dann überlaufen könnte)

also

inputstream.read(); 
// holt ein Byte
Thread.sleep(sehrlange); 
// bin gemein und hol das nächste nicht ab...

ist Mist, weil dann der Eingangspuffer überlaufen könnte