java反序列化和序列化在同一个进程中

Question

我在序列化和反序列化同一 JVM 中的对象列表时遇到问题。确切地说，现在我的对象拥有对 Alphabet 对象的相同引用，该对象具有以下规则：

    VMID instanceId = new VMID();  //used in readResolve to identify persitent instances

    public Alphabet (int capacity, Class entryClass) {
        this.map = new gnu.trove.TObjectIntHashMap (capacity);
        this.entries = new ArrayList (capacity);
        this.entryClass = entryClass;
        // someone could try to deserialize us into this image (e.g., by RMI).  Handle this.
        deserializedEntries.put (instanceId, this);
    }

    public VMID getInstanceId() {
        return instanceId;
    } // for debugging

    public void setInstanceId(VMID id) { this.instanceId = id; }

    // Serialization
    private static final long serialVersionUID = 1;

    private static final int CURRENT_SERIAL_VERSION = 1;

    private void writeObject (ObjectOutputStream out) throws IOException {
        out.writeInt (CURRENT_SERIAL_VERSION);
        out.writeInt (entries.size());
        for (int i = 0; i < entries.size(); i++) {
            out.writeObject (entries.get(i));
        }
        out.writeBoolean (growthStopped);
        out.writeObject (entryClass);
        out.writeObject(instanceId);
    }

    private void readObject (ObjectInputStream in) throws IOException, ClassNotFoundException {
        int version = in.readInt ();
        int size = in.readInt();
        entries = new ArrayList (size);
        map = new gnu.trove.TObjectIntHashMap (size);
        for (int i = 0; i < size; i++) {
            Object o = in.readObject();
            map.put (o, i);
            entries. add (o);
        }
        growthStopped = in.readBoolean();
        entryClass = (Class) in.readObject();
        if (version >0 ){ // instanced id added in version 1S
            instanceId = (VMID) in.readObject();
        }
    }

    private transient static HashMap deserializedEntries = new HashMap();
    /**
     * This gets called after readObject; it lets the object decide whether
     * to return itself or return a previously read in version.
     * We use a hashMap of instanceIds to determine if we have already read
     * in this object.
     * @return
     * @throws ObjectStreamException
     */

    public Object readResolve() throws ObjectStreamException {
        Object previous = deserializedEntries.get(instanceId);
        if (previous != null){
            //System.out.println(" ***Alphabet ReadResolve:Resolving to previous instance. instance id= " + instanceId);
            return previous;
        }
        if (instanceId != null){
            deserializedEntries.put(instanceId, this);
        }
        //System.out.println(" *** Alphabet ReadResolve: new instance. instance id= " + instanceId);
        return this;
    }

现在在我的对象列表反序列化之后，在某些时候字母表引用不匹配。我使用以下方法进行了检查：

for (Instance i: finalTrainingDocs){
    if (!i.getTargetAlphabet().equals(finalTraining.getTargetAlphabet())){
        System.out.println("not equals");
        System.out.println(i.getTargetAlphabet().getInstanceId() + " " + finalTraining.getTargetAlphabet().getInstanceId());
    }
    finalTraining.add(i);
    counter++;
    System.out.println("counter " + counter);
}

并得到以下结果

counter 237
counter 238
counter 239
not equals
3ce62156867eb540:6b7f0de5:141e51fcd67:-7ffa 3ce62156867eb540:6b7f0de5:141e51fcd67:-7ffa

现在查看 VMId，因为它们是相同的，所以它不应该是同一个对象，就像上面的逻辑一样？感谢您的帮助。

Answer 1

一种可能性是您有竞争条件；即两个线程同时更新deserializedEntries hashmap。这可能会导致您拥有两个具有相同 instanceId 值的 Alphabet 实例。

将deserializedEntries 声明为volatile 不足以防止这种情况发生。 （事实上​​，您不充分的同步甚至可能导致 hashmap 的内部数据结构被破坏。）

---

我不相信你正在做的是一个好主意。除了这种脆弱性（需要更多的重量级同步来修复）之外，您还面临哈希映射是内存泄漏的问题。我怀疑通过接受 Alphabet 实例重复并覆盖 equals 来处理此问题，您将获得更好的性能。

Answer 2

您正在根据版本读取 instanceId

if (version >0 ){ // instanced id added in version 1S
    instanceId = (VMID) in.readObject();
}

所以这里需要同样的条件

 if (CURRENT_SERIAL_VERSION >0 ){ 
      out.writeObject(instanceId);