public void sendAllStreamData() throws InterruptedException {

		// In welchem Modus werden die Pakete versandt (jeder Stream verschickt nr ein Paket und reiht sich dann erneut ein, oder
		// jeder Stream verschickt soviele Pakete wie er darf).
		boolean singlePacketMode;

		// Solange es Streams gibt, die Senden dürfen
		while (_numberTerminatedStreams < _numberOfStreams) {

			// Ein Element aus der Warteschlange anfordern.
			// Anmerkung, in der Zwischenzeit kann der StreamMultiplexer unterbrochen worden sein (killAllStreams).
			// Dieser Abbruch kann notwenig gewesen sein, weil der StreamDemultiplexer physich nicht mehr zu erreichen war,
			// es würden also keine Tickets mehr verschickt und somit würde es auch keine Sendebereiten Streams mehr geben.
			// Der Thread der den folgenden Aufruf tätigt würde also nie wieder die Queue verlassen können.
			// Der Aufruf <code>killAllStreams</code> legt einen Dummy-Stream in die Queue, der abgebrochen wurde.
			// Somit wird der hier wartende Thread befreit und verläßt die while-Schleife.
			IndexOfStreamAndMaxSendPackets paketsForStream = (IndexOfStreamAndMaxSendPackets) _queueWithStreamsPermitedToSendData.take();

			// Welcher Stream darf Nutzdatenpakete verschicken
			int indexOfStream = paketsForStream.getIndexOfStream();

			// Falls der Stream noch nicht mit Abort abgebrochen wurde, darf der Stream senden.
			// Somit werden alle Streams, die noch in der Warteschleife stehen aber abgebrochen wurden,
			// langsam aus der Warteschlange entfernt ohne Daten zu verschicken.

			MultiplexerStreaminformations stream = _streams[indexOfStream];
			synchronized (stream) {

				// Wurde der Stream bereits abgebrochen ?
				if (stream.isStreamTerminated() == false) {
					_debug.finer("\n\t\t\t\t\t\t\t\t\t\tSender verschickt Nutzdatenpaket(e)");

					// Wie viele Pakete sollen auf einmal verschickt werden. Ist der single Modus aktiv, dann nur eins.
					// Im anderen Fall soviele wie erlaubt.
					final int numberOfPackets;

					if (_queueWithStreamsPermitedToSendData.size() == 0) {
						// Die Schlange ist leer, somit kann der gerade gewählte Stream alle Nutzdatenpakete verschicken
						// die er verschicken darf.
						singlePacketMode = false;
						// Wie viele Pakete sollen verschickt werden (in diesem Modus so viele wie möglich)
						numberOfPackets = paketsForStream._maxSendPackets;
					} else {
						// Es gibt noch andere Streams die senden möchten. Also verschickt jeder nur ein Nutzdatenpaket
						// und reiht sich dann wieder in der Warteschlange ein.
						singlePacketMode = true;
						// Wie viele Pakete sollen verschickt werden (in diesem Modus nur eins)
						numberOfPackets = 1;
					}

					for (int nr = 0; nr < numberOfPackets; nr++) {

						// Wie viele Nutzdatenpackete hat der Stream schon verschickt. Hinweis: Das Array wird mit "0" in jedem Eintrag initialisiert.
						int currentStreamPacketIndex = stream.getCurrentStreamPacketIndex();
						// Ein Paket verschicken
						currentStreamPacketIndex++;

						// Nutzdaten von der "Applikation" anfordern, wenn die Applikation eine "null" zurück gibt, dann sind
						// keine Nutzdaten mehr vorhanden. Der stream kann also beendet werden.
						byte[] data = take(indexOfStream);

						// Debug
						_debug.finer("\t\t\t\t\t\t\t\t\t\tPaketdaten: Stream(" + indexOfStream + ") Paketindex(" + currentStreamPacketIndex + ") Anzahl Pakete, die zu diesem Satz gehören (" + numberOfPackets + ")" + "Paketnummer des Satzes (Nummer 0 ist das erste Paket)) (" + nr + ")");

						// Das mit take angeforderte große Nutzdatenpaket verschicken
						sendDataToReceiver(indexOfStream, currentStreamPacketIndex, data);
						// Da ein Paket verschickt wurde, muß der neue Index gespeichert werden
						stream.setCurrentStreamPacketIndex(currentStreamPacketIndex);

						// Wenn bei dem Aufruf der take Methode ein null-Paket verpackt wurde, dann wird der Stream dort
						// mit <code>setStreamTerminated</code> beendet. Das angelegte Paket WURDE aber noch verschickt.
						// Allerdings werden für den Stream keine weiteren Pakete mehr versandt.
						if (stream.isStreamTerminated()) {
							// Es gibt für den Stream keine Nutzdaten mehr, der Sender beendet auf seiner Seite den Stream.
							// Der Empfänger muß nicht benachrichtigt werden, da er ein Nutzdatenpaket mit leeren
							// Nutzdaten empfängt. Er wird daraufhin auf seiner Seite den Stream
							// ebenfalls beenden (Der Sender wird davon nicht benachrichtigt, da er den Stream sowieso schon beendet hat).

							// Nun brauchen die restlichen Pakete nicht mehr verschickt werden, die For-Schleife kann abgebrochen werden
							break;
						}
					}

					if ((singlePacketMode == true) && (stream.isStreamTerminated() == false)) {
						// Im Single-Modus wird nur ein Paket verschickt, wenn der Stream noch Daten verschicken darf

						// Da ein Paket verschickt wurde, darf der Stream ein Paket weniger verschicken als vorher
						paketsForStream.decrementMaxSendPackets();
						if (paketsForStream.getMaxSendPackets() > 0) {
							// Der Stream darf noch Nutzdaten verschicken, also wird er wieder in die Warteschlange eingefügt.
							// Wurden alle Nutzdatenpakete verschickt ("virtueller else Zweig"), dann muß nichts gemacht werden.

							_queueWithStreamsPermitedToSendData.put(paketsForStream);
						}
					}

					_debug.finest("\t\t\t\t\t\t\t\t\t\t Anzahl verschickter Pakete(alle Streams) = " + _numberOfPacketsSend);
				}
			}
		}
//		_debug.info("sendAllStreamData: _dataCount = " + _dataCount + ", Anzahl verschickter Pakete(alle Streams) = " + _numberOfPacketsSend + ", _numberTerminatedStreams = " + _numberTerminatedStreams + ", _numberOfStreams = " + _numberOfStreams);
		_debug.finer("StreamMultiplexer beendet sich");
	}