From b5349c072a2f84682531da24f1a80cd7016b8465 Mon Sep 17 00:00:00 2001 From: Bryce McKinlay Date: Fri, 2 Jul 2004 19:41:33 +0000 Subject: [PATCH] Locale.java (hashcode): Made transient. * java/util/Locale.java (hashcode): Made transient. (hashCode): No longer synchronized. (equals): Remove comment. (writeObject): No longer synchronized. Implement using writeObject calls instead of tweaking hashCode field. Update doc. (readObject): Implement using readObject calls. From-SVN: r84027 --- libjava/ChangeLog | 9 +++++++++ libjava/java/util/Locale.java | 35 +++++++++++++++++------------------ 2 files changed, 26 insertions(+), 18 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 8df39520d91..d99f402ccc0 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,12 @@ +2004-07-02 Bryce McKinlay + + * java/util/Locale.java (hashcode): Made transient. + (hashCode): No longer synchronized. + (equals): Remove comment. + (writeObject): No longer synchronized. Implement using writeObject + calls instead of tweaking hashCode field. Update doc. + (readObject): Implement using readObject calls. + 2004-06-26 Geoffrey Keating Andreas Tobler diff --git a/libjava/java/util/Locale.java b/libjava/java/util/Locale.java index cc6d65f5f65..ca6334cb334 100644 --- a/libjava/java/util/Locale.java +++ b/libjava/java/util/Locale.java @@ -186,7 +186,7 @@ public final class Locale implements Serializable, Cloneable * * @serial should be -1 in serial streams */ - private int hashcode; + private transient int hashcode; /** * The default locale. Except for during bootstrapping, this should never be @@ -709,10 +709,8 @@ public final class Locale implements Serializable, Cloneable * * @return the hashcode */ - public synchronized int hashCode() + public int hashCode() { - // This method is synchronized because writeObject() might reset - // the hashcode. return hashcode; } @@ -731,10 +729,6 @@ public final class Locale implements Serializable, Cloneable return false; Locale l = (Locale) obj; - // ??? We might also want to add: - // hashCode() == l.hashCode() - // But this is a synchronized method. Is the overhead worth it? - // Measure this to make a decision. return (language == l.language && country == l.country && variant == l.variant); @@ -745,17 +739,19 @@ public final class Locale implements Serializable, Cloneable * * @param output the stream to write to * @throws IOException if the write fails - * @serialData the hashcode should always be written as -1, and recomputed - * when reading it back + * @serialData The first three fields are Strings representing language, + * country, and variant. The fourth field is a placeholder for + * the cached hashcode, but this is always written as -1, and + * recomputed when reading it back. */ - private synchronized void writeObject(ObjectOutputStream output) + private void writeObject(ObjectOutputStream s) throws IOException { - // Synchronized so that hashCode() doesn't get wrong value. - int tmpHashcode = hashcode; - hashcode = -1; - output.defaultWriteObject(); - hashcode = tmpHashcode; + s.writeObject(language); + s.writeObject(country); + s.writeObject(variant); + // Hashcode field is always written as -1. + s.writeInt(-1); } /** @@ -766,10 +762,13 @@ public final class Locale implements Serializable, Cloneable * @throws ClassNotFoundException if reading fails * @serialData the hashCode is always invalid and must be recomputed */ - private void readObject(ObjectInputStream input) + private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { - input.defaultReadObject(); + language = (String) s.readObject(); + country = (String) s.readObject(); + variant = (String) s.readObject(); + // Recompute hashcode. hashcode = language.hashCode() ^ country.hashCode() ^ variant.hashCode(); } } // class Locale -- 2.30.2