Difference Between flush() vs reset() in JAVA

I was just wondering what the difference between flush and reset is?
Why is it using reset after flush in example? Why is reset method used if memory cache is wiped by flush method?

ObjectOutputStream oos = new ObjectOutputStream(bos);

while(true){
oos.writeObject(object);
oos.flush();
oos.reset();

object.x++;
}


3 Answers
3

Why is reset method used if memory cache is wiped by flush method?

flush() will write the buffer of the ObjectOutputStream object in the underlying OutputStream but it will not reset the whole state of the ObjectOutputStream object.

flush()

ObjectOutputStream

OutputStream

ObjectOutputStream

If you open the ObjectOutputStream source code class, you can see that beyond the buffer it contains many instance fields.
Here is a little snippet :

ObjectOutputStream

/** filter stream for handling block data conversion */
private final BlockDataOutputStream bout;
/** obj -> wire handle map */
private final HandleTable handles;
/** obj -> replacement obj map */
private final ReplaceTable subs;
/** recursion depth */
private int depth;
/** buffer for writing primitive field values */
private byte primVals;


Some handle the conversion, others handle the cache, and so for...
ObjectOutputStream.reset() will have effects on this state :

ObjectOutputStream.reset()

Reset will disregard the state of any objects already written to the
stream.

and

Objects previously written to the stream will not be referred to as
already being in the stream. They will be written to the stream again.

These detail matter as ObjectOutputStream uses a reference sharing mechanism.
So writing in the stream multiple times the same object but with a different state will write the object with the original state multiple times.
The top level documentation of ObjectOutputStream explains that and more (emphasis is mine) :

ObjectOutputStream

The default serialization mechanism for an object writes the class of
the object, the class signature, and the values of all non-transient
and non-static fields. References to other objects (except in
transient or static fields) cause those objects to be written also.
Multiple references to a single object are encoded using a reference
sharing mechanism so that graphs of objects can be restored to the
same shape as when the original was written.

You should now understand the reset() meaning.

reset()

Example illustrating a cache issue with ObjectOutputStream:

ObjectOutputStream

Execute this class that write 10 times the same object but with a different state i nan ObjectOutputStream without invoking reset() between the writings :

ObjectOutputStream

reset()

public class FlushAndReset {

public static void main(String args) throws IOException, ClassNotFoundException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);

Foo foo = new Foo();
for (int i = 0; i < 10; i++) {
foo.setValue(i);
oos.writeObject(foo);
oos.flush();
// oos.reset();
}

ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
for (int i = 0; i < 10; i++) {
Object obj = ois.readObject();
System.out.println(obj);
}
}
}


With Foo defined as :

public class Foo implements Serializable {

private int value;

public void setValue(int value) {
this.value = value;
}

@Override
public String toString() {
return "Foo [value=" + value + "]";
}

}


As you will read the content of the BOS you will get :

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Foo [value=0]

Uncomment the reset() and you should see the change :

reset()

Foo [value=0]

Foo [value=1]

Foo [value=2]

Foo [value=3]

Foo [value=4]

Foo [value=5]

Foo [value=6]

Foo [value=7]

Foo [value=8]

Foo [value=9]

The reset() will disregard the state of any objects already written to the
stream. The state is reset to be the same as a new ObjectOutputStream.
The current point in the stream is marked as reset so the
corresponding ObjectInputStream will be reset at the same point.
Objects previously written to the stream will not be refered to as
already being in the stream. They will be written to the stream again.

The flush() method flushes the stream. This will write any buffered
output bytes and flush through to the underlying stream.

The flush() method will do clear the buffer and write to the stream while reset() will be used to change the objects which were already written to the stream.

flush()

reset()

reset() will invalidate all objects that have been sent. If you are sending unchanged objects again only a reference is transmitted allowing to reuse the cached version of the already transmitted object. This is much more efficient than always sending the entire object.

reset()

In your example the value of objects's member x is increased, thus the object changes. If you need to send the changed values it is necesarry to call reset() first so that the object is actually rewritten to the stream.

reset()

On the other hand flush() will only make sure that data is actually written to the stream. The write operation will only put data to the buffer and may write it to the stream depending on the buffer size. Calling flush() will guarantee that the data is written to the stream. But flush will not clear the cached objects.

flush()

flush()

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.