So, you and Chris Uppal's post as well, are agreeing that the
constructor is called during deserialization.

I want an object that has a state that is initialized only once, as a
result of an external side-effect. I also want it to be possible for
that state to be serialized, without the state being "reinitialized"
(in the sense of being intitialized again by a specific block of code)
during deserialization. I want the state (the field values) restored,
without the code that initializes them during construction being
called.

In any case, I found information about writeObject in:

http://java.sun.com/j2se/1.3/docs/guide/serialization/spec/examples.doc1.html

Based on that, I have this mutation of the java developer almanac
serializable singleton that seems to survive deserialization. The
external side-effect is represented by retrieving a system property.

The one instance of the class would be normally be referenced using:

MySingleton.instance();

If it were deserialized, the reference would be faked using:

(MySingleton) objectInputStream.readObject();

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectStreamField;
import java.io.Serializable;

public class MySingleton implements Serializable {
   private static final ObjectStreamField[] serialPersistentFields = {
       new ObjectStreamField("instance", MySingleton.class),
       new ObjectStreamField("value", String.class)
   };
   private static MySingleton instance = null;
   private String value = null;
   private MySingleton() {
       System.out.println("Constructing MySingleton");
   }
   private MySingleton(boolean f) {
       System.out.println("Constructing MySingleton f");
       System.out.println("Setting value to " +
                       System.getProperty("abc"));
       value = System.getProperty("abc");
   }
   public String value() { return value; }
   public static MySingleton instance() {
       if (instance == null) {
           instance = new MySingleton(true);
       }
       return instance;
   }
   private void writeObject(ObjectOutputStream s) throws IOException {
       ObjectOutputStream.PutField fields = s.putFields();
       fields.put("instance", instance);
       fields.put("value", value);
       s.writeFields();
   }
   private void readObject(ObjectInputStream s) throws IOException {
       try {
           ObjectInputStream.GetField fields = s.readFields();
           instance = (MySingleton) fields.get("instance", null);
           value = (String) fields.get("value", null);
       } catch (ClassNotFoundException cnfe) {
           throw new IOException("" + cnfe);
       }
   }
}