das Thema wurde ja mal völlig übersprungen???

public class Solution {
    public Solution append(CharSequence s) {
        if (s == null) {
            s = "null"; // CharSequence is read only, immutable -> no synchronization needed
        }

        if (s instanceof String) {
            return this.append((String) s); // ?? huh infinite loop or what -> so that does nothing at all. Casting to string is superfluous, too
        }

        if (s instanceof Solution) {
            return this.appendThis((Solution) s); // if the passed argument is a Solution object call appendThis, that method is probably modifying data and needs synchronization
        }

        return this.append(s); // call append again? What? If s eg. is a StringBuilder it's calling itself repeatedly like mentioned above.
    }

    public synchronized Solution appendThis(Solution s) { // here the work is done and I assume value and count changed
        // Etwas tun....
        return this;
    }

// An array of ObjectStreamFields is used to declare the Serializable fields of a class
    // serialPersistentFields not used... ?? why then it is here... to confuse me
    private static final java.io.ObjectStreamField[] serialPersistentFields =
            {
...
            };

    // An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream
    // didn't find and usable info about synchronization in the API documentation so I assume writeObject is not synchronized -> synchronizing this method
    private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
....

        s.writeFields();
    }

    // I assumed here the same as for writeObject, and if reading and writing happens simultaneously then both need to be synchronized
    // so why tells me CG that readObject mustn't be synchronized
    // after doing some testes I've seen that opening a FileOutputStream locks that file... one can't access that file
    // anymore using another in- or output stream. So once the OutputStream is open, access is effectively locked
    // (it needs to be synchronized if threads a and b use the same output stream resource though).
    // So reading would do no harm as it can't happen at the same time as writing... ?? Or may it cause problems
    // cause thread B could modify value and count fields while we are reading that data and restoring that fields?
    // I don't get it...
    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
....
    }

    public static void main(String[] args) {
        // debug code
        // new Solution().append(new StringBuilder("123"));
    }

//serialize
Solution myClass = new Solution(/*some arguments to initialize*/);
OOS out = new OOS(new FileOS(fileName));
out.writeObject(myClass); // called on the output stream, not the object

//deserialize
OIS in = new OIS(new FileIS(fileName));
Solution deserializedMyClass = (Solution) in.readObject();