java - seda - ¿Qué sucede cuando envuelvo las transmisiones de E/S dos veces?

con que papel se envuelven los besos de moza

Question

Sé que Java I / O usa un patrón de decorador. Pero siento que entiendo que está mal.

Por favor, aclare la diferencia entre dos fragmentos de código:

fragmento 1:

    PipedInputStream pipedInputStream = new PipedInputStream();
    PipedOutputStream pipedOutputStream = new PipedOutputStream();
    pipedOutputStream.connect(pipedInputStream);


    ObjectOutputStream objectOutputStream = new ObjectOutputStream(pipedOutputStream);

    objectOutputStream.writeObject("this is my string");

    ObjectInputStream objectInputStream = new ObjectInputStream(pipedInputStream);

    System.out.println(objectInputStream.readObject());

Esta aplicación funciona de acuerdo con mis expectativas y veo el resultado en la consola.

fragmento 2:

Intento ajustar ObjectInputStream y ObjectOutputStream dos veces:

        PipedInputStream pipedInputStream = new PipedInputStream();
        PipedOutputStream pipedOutputStream = new PipedOutputStream();
        pipedOutputStream.connect(pipedInputStream);


        ObjectOutputStream objectOutputStream = new ObjectOutputStream(pipedOutputStream);
        ObjectOutputStream objectOutputStreamWrapper = new ObjectOutputStream(objectOutputStream);     //double wrapping

        objectOutputStreamWrapper.writeObject("this is my string");

        ObjectInputStream objectInputStream = new ObjectInputStream(pipedInputStream);
        ObjectInputStream   objectInputStreamWrapper = new ObjectInputStream(objectInputStream);

        System.out.println(objectInputStreamWrapper.readObject());

Este código solo cuelga. No entiendo por qué. Por favor aclara

PD

Es solo una pregunta teórica.

ACTUALIZAR

Realmente cuelga el comportamiento pasa porque uso tubos (Según la respuesta de EJP).

por ejemplo, este código funciona de acuerdo con las expectativas.

            OutputStream outputStream = new FileOutputStream("2.txt");

            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            ObjectOutputStream objectOutputStreamWrapper = new ObjectOutputStream(objectOutputStream);     //double wrapping

            objectOutputStreamWrapper.writeObject("this is my string");
            objectOutputStream.close();

            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("2.txt"));
            ObjectInputStream   objectInputStreamWrapper = new ObjectInputStream(objectInputStream);


            System.out.println(objectInputStreamWrapper.readObject());
            objectInputStream.close();

Parece que si envuelvo la entrada de 10 decoradores, debo ajustar la salida de 10 decoradores en el mismo orden. Es verdad ?

ACTUALIZACIÓN + 1

Solo noté ese problema con el enrojecimiento:

PipedInputStream pipedInputStream = new PipedInputStream();
    PipedOutputStream pipedOutputStream = new PipedOutputStream();
    pipedOutputStream.connect(pipedInputStream);


    ObjectOutputStream objectOutputStream = new ObjectOutputStream(pipedOutputStream);
    ObjectOutputStream objectOutputStreamWrapper = new ObjectOutputStream(objectOutputStream);     //double wrapping

    objectOutputStreamWrapper.writeObject("this is my string");

    objectOutputStreamWrapper.flush();

    ObjectInputStream objectInputStream = new ObjectInputStream(pipedInputStream);
    ObjectInputStream   objectInputStreamWrapper = new ObjectInputStream(objectInputStream);

    System.out.println(objectInputStreamWrapper.readObject());

Answer 1

Estás haciendo un uso incorrecto de las transmisiones por tubería. Están destinados a ser utilizados por un hilo productor haciendo escrituras y un hilo de consumo haciendo lecturas. Ver el Javadoc.

Las transmisiones canalizadas comparten un búfer que puede llenarse si el hilo de lectura no está leyendo, lo que detiene su hilo de escritura.

Envolviendo las transmisiones dos veces no tiene nada que ver con eso, aunque en este caso ciertamente no tiene sentido ni es problemático.

Answer 2

PipedInputStream pipedInputStream = new PipedInputStream();
PipedOutputStream pipedOutputStream = new PipedOutputStream();
pipedOutputStream.connect(pipedInputStream);
//writing 
ObjectOutputStream objectOutputStream = new ObjectOutputStream(pipedOutputStream);
//ObjectOutputStream objectOutputStreamWrapper =new ObjectOutputStream(objectOutputStream);
//ObjectOutputStream objectOutputStreamWrapper1=new ObjectOutputStream(objectOutputStreamWrapper);
//objectOutputStreamWrapper1.writeObject("this is my string");
//objectOutputStreamWrapper1.flush();
objectOutputStream.writeObject("this is my string");
//reading 
ObjectInputStream objectInputStream = new ObjectInputStream(pipedInputStream);
//ObjectInputStream objectInputStreamWrapper = new ObjectInputStream(objectInputStream);
//ObjectInputStream objectInputStreamWrapper1=new ObjectInputStream(objectInputStreamWrapper);
//System.out.println("going to read from piped source");
//System.out.println(objectInputStreamWrapper1.readObject());
System.out.println(objectInputStream.readObject());

Fragmento 1 - OutputStream creado con la corriente Piped, luego la corriente de entrada recibe directamente los datos de la tubería a través del búfer sin enjuagar.

Actualización + 1 - OutputStream creado con un wrapper de salida a su vez con otro wrapper (comentó los estatutos del contenedor) y así sucesivamente funciona después de la declaración de vaciado. Flush explícitamente vacía los datos almacenados en el búfer a la secuencia subyacente, en nuestro caso una secuencia de salida canalizada o la secuencia de salida.

La secuencia anidada se puede usar como FilterOutputStream también se puede usar encima de ObjectOutputStream.