package javacodebook.thread.pipes;

import java.io.InputStream;
import java.util.Random;

/**
 * Dieser Thread versucht in unregelmäßigen Abständen Zahlen (Bytes) aus der
 * ihm zur Verfügung gestellten Pipe zu lesen und auf der Standardausgabe
 * auszugeben.
 */
class DataSink extends Thread {
    InputStream is;
    Random random;

    public DataSink(InputStream is) {
        this.is = is;
        this.random = new Random(System.currentTimeMillis());
    }

    public void run() {
        byte[] buf = new byte[1];
        int size = 0;

        try {
            // Der Thread läuft solange, bis die Pipe von der anderen Seite
            // geschlossen wird.
            while(true) {
                // Es wird versucht, ein Byte aus der Pipe zu lesen. Der Aufruf
                // wird erst dann abgeschlossen, wenn mind. ein Byte zur
                // Verfügung steht oder die Pipe geschlossen wurde.
                size = is.read(buf, 0, 1);

                // In der Pipe stehen keine Daten mehr zur Verfügung.
                if (size < 0)
                    break;

                // Das gelesene Byte wird ausgegeben.
                System.out.println("\t\t" + buf[0]);
                sleepRandomly(200, 300);
            }
            System.out.println("\t\tEOF");
            is.close();
        }
        catch (Exception ignore)
        {}
    }

    /**
     * Versetzt den Thread in einen Schlaf, der mindestens min und maximal max
     * Millisekunden dauert.
     */
    private void sleepRandomly(int min, int max) {
        try {
            int duration = random.nextInt(max-min);
            sleep(duration+min);
        }
        catch (Exception ignore)
        {}
    }
}

--- Neue Klasse ---

package javacodebook.thread.pipes;

import java.io.OutputStream;
import java.util.Random;

/**
 * Dieser Thread schreibt in unregelmäßigen Abständen Zahlen (Bytes) in den
 * ihm zur Verfügung gestellten OutputStream.
 */
class DataSource extends Thread {
    OutputStream os;
    Random random;

    public DataSource(OutputStream os) {
        this.os = os;
        this.random = new Random(System.currentTimeMillis());
    }

    public void run() {
        byte buf[] = new byte[1];

        try {
            // Es werden insgesamt 10 Zahlen in die Pipe geschrieben
            for (int i=0; i<10; i++) {
                // Eine neue Zufallszahl erzeugen ...
                buf[0] = (byte)random.nextInt(127);
                // .. auf der Konsole ausgeben ...
                System.out.println(buf[0]);
                // ... und in die Pipe schreiben
                os.write(buf, 0, 1);
                // Nach getaner Arbeit erst einmal pausieren.
                sleepRandomly(200, 300);
            }
            System.out.println("EOF");
            os.close();
        }
        catch (Exception ignore) {}
    }

    /**
     * Versetzt den Thread in einen Schlaf, der mindestens min und maximal max
     * Millisekunden dauert.
     */
    private void sleepRandomly(int min, int max) {
        try {
            int duration = random.nextInt(max-min);
            sleep(duration+min);
        }
        catch (Exception ignore) {}
    }
}

--- Neue Klasse ---

package javacodebook.thread.pipes;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

/**
 * Start des Beispieles.
 *
 * Es werden zwei Threads erzeugt. Der erste Thread generiert in unregelmäßigen
 * Zeitabständen Zufallszahlen und schreibt diese in eine ihm zur Verfügung
 * gestellte Pipe. Der zweite Thread versucht seinerseits in unregelmäßigen
 * Abständen, Daten aus der Pipe zu lesen.
 */
public class Starter {
    public static void main(String []args) throws IOException {
        // Zunächst einmal werden die Enden der Pipe erstellt und miteinander
        // verbunden.
        PipedInputStream  pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream(pis);

        // Schreibender und lesender Thread werden erzeugt und gestartet.
        // Zur Kommunikation wird ihnen die erstellte Pipe übergeben.
        Thread sink   = new DataSink(pis);
        Thread source = new DataSource(pos);

        sink.start();
        source.start();
    }
}