java una Cosa succede quando avvolgo i flussi di I/O due volte?




title tags in wordpress (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());

Snippet 1: OutputStream creato con stream Piped, quindi il flusso di input riceve direttamente i dati dalla pipe attraverso il buffer senza eseguire il flushing.

Update + 1 - OutputStream creato con wrapper outputstream a sua volta con un altro wrapper (commentato le impostazioni del wrapper) e così via dopo la svuota della statistica. Flush esegue esplicitamente lo svuotamento dei dati bufferizzati nel flusso sottostante, nel nostro caso un flusso di output con pipe o il flusso di output.

È possibile utilizzare lo stream nidificato come anche FilterOutputStream può essere utilizzato anche su ObjectOutputStream.

So che java I / O utilizza il pattern decoratore. Ma sento di capire che è sbagliato.

Si prega di chiarire la differenza tra due frammenti di codice:

frammento 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());

Questa applicazione funziona secondo le mie aspettative e vedo i risultati in console.

snippet 2:

Provo a racchiudere ObjectInputStream e ObjectOutputStream due volte:

        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());

Questo codice è appena riagganciato. Non capisco perché. si prega di precisare.

PS

È solo una domanda teorica.

AGGIORNARE

Appende davvero il comportamento accade a causa di io uso tubi (Secondo la risposta EJP).

per esempio questo codice funziona secondo le aspettative.

            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();

sembra che se inserissi l'input di 10 decoratori, dovrei completare l'output di 10 decoratori nello stesso ordine. È vero ?

AGGIORNAMENTO + 1

Ho notato che il problema con lo svuotamento è solo:

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());

Stai abusando di stream convogliati. Sono concepiti per essere utilizzati da un thread di produzione che fa le scritture e un thread del consumatore che sta leggendo. Vedi il Javadoc.

Gli stream con pipe condividono un buffer che può essere riempito se il thread di lettura non sta leggendo, il che blocca il thread di scrittura.

Avvolgere i flussi due volte non ha nulla a che fare con questo, anche se in questo caso è certamente sia inutile che problematico.





decorator