jdk-sandbox: comparison jdk/src/java.base/share/classes/java/security/Permissions.java

equal deleted inserted replaced

-:a6b5f444cb68
+:00a25f4c4d44
 import java.util.Map;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Iterator;
 import java.util.Collections;
+import java.util.concurrent.ConcurrentHashMap;
 import java.io.Serializable;
 import java.io.ObjectStreamField;
 import java.io.ObjectOutputStream;
 import java.io.ObjectInputStream;
 import java.io.IOException;
 {
 /**
 * Key is permissions Class, value is PermissionCollection for that class.
 * Not serialized; see serialization section at end of class.
 */
-private transient Map<Class<?>, PermissionCollection> permsMap;
+private transient ConcurrentHashMap<Class<?>, PermissionCollection> permsMap;
 // optimization. keep track of whether unresolved permissions need to be
 // checked
 private transient boolean hasUnresolved = false;
 /**
 * Creates a new Permissions object containing no PermissionCollections.
 */
 public Permissions() {
-permsMap = new HashMap<>(11);
+permsMap = new ConcurrentHashMap<>(11);
 allPermission = null;
 }
 /**
 * Adds a permission object to the PermissionCollection for the class the
 * @exception SecurityException if this Permissions object is
 * marked as readonly.
 *
 * @see PermissionCollection#isReadOnly()
 */
+@Override
 public void add(Permission permission) {
 if (isReadOnly())
 throw new SecurityException(
 "attempt to add a Permission to a readonly Permissions object");
-PermissionCollection pc;
+PermissionCollection pc = getPermissionCollection(permission, true);
+pc.add(permission);
-synchronized (this) {
-pc = getPermissionCollection(permission, true);
-pc.add(permission);
-}
 // No sync; staleness -> optimizations delayed, which is OK
 if (permission instanceof AllPermission) {
 allPermission = pc;
 }
 *
 * @return true if "permission" is implied by the permissions in the
 * PermissionCollection it
 * belongs to, false if not.
 */
+@Override
 public boolean implies(Permission permission) {
 // No sync; staleness -> skip optimization, which is OK
 if (allPermission != null) {
 return true; // AllPermission has already been added
 } else {
-synchronized (this) {
+PermissionCollection pc = getPermissionCollection(permission,
-PermissionCollection pc = getPermissionCollection(permission,
+false);
-false);
+if (pc != null) {
-if (pc != null) {
+return pc.implies(permission);
-return pc.implies(permission);
+} else {
-} else {
+// none found
-// none found
+return false;
-return false;
-}
 }
 }
 }
 /**
 * Returns an enumeration of all the Permission objects in all the
 * PermissionCollections in this Permissions object.
 *
 * @return an enumeration of all the Permissions.
 */
+@Override
 public Enumeration<Permission> elements() {
 // go through each Permissions in the hash table
 // and call their elements() function.
-synchronized (this) {
+return new PermissionsEnumerator(permsMap.values().iterator());
-return new PermissionsEnumerator(permsMap.values().iterator());
-}
 }
 /**
 * Gets the PermissionCollection in this Permissions object for
 * permissions whose type is the same as that of <i>p</i>.
 * implies() because it incurs the additional overhead of creating and
 * adding an empty PermissionCollection that will just return false.
 * It should be set to true when invoked from add().
 */
 private PermissionCollection getPermissionCollection(Permission p,
 boolean createEmpty) {
 Class<?> c = p.getClass();
-PermissionCollection pc = permsMap.get(c);
 if (!hasUnresolved && !createEmpty) {
-return pc;
+return permsMap.get(c);
-} else if (pc == null) {
+}
-// Check for unresolved permissions
+// Create and add permission collection to map if it is absent.
-pc = (hasUnresolved ? getUnresolvedPermissions(p) : null);
+// NOTE: cannot use lambda for mappingFunction parameter until
+// JDK-8076596 is fixed.
-// if still null, create a new collection
+return permsMap.computeIfAbsent(c,
-if (pc == null && createEmpty) {
+new java.util.function.Function<>() {
+@Override
-pc = p.newPermissionCollection();
+public PermissionCollection apply(Class<?> k) {
+// Check for unresolved permissions
-// still no PermissionCollection?
+PermissionCollection pc =
-// We'll give them a PermissionsHash.
+(hasUnresolved ? getUnresolvedPermissions(p) : null);
-if (pc == null)
-pc = new PermissionsHash();
+// if still null, create a new collection
+if (pc == null && createEmpty) {
+pc = p.newPermissionCollection();
+// still no PermissionCollection?
+// We'll give them a PermissionsHash.
+if (pc == null) {
+pc = new PermissionsHash();
+}
+}
+return pc;
+}
 }
+);
-if (pc != null) {
-permsMap.put(c, pc);
-}
-}
-return pc;
 }
 /**
 * Resolves any unresolved permissions of type p.
 *
 *  or null if there were no unresolved permissions of type p.
 *
 */
 private PermissionCollection getUnresolvedPermissions(Permission p)
 {
-// Called from within synchronized method so permsMap doesn't need lock
 UnresolvedPermissionCollection uc =
 (UnresolvedPermissionCollection) permsMap.get(UnresolvedPermission.class);
 // we have no unresolved permissions if uc is null
 if (uc == null)
 // Don't call out.defaultWriteObject()
 // Copy perms into a Hashtable
 Hashtable<Class<?>, PermissionCollection> perms =
 new Hashtable<>(permsMap.size()*2); // no sync; estimate
-synchronized (this) {
+perms.putAll(permsMap);
-perms.putAll(permsMap);
-}
 // Write out serializable fields
 ObjectOutputStream.PutField pfields = out.putFields();
 pfields.put("allPermission", allPermission); // no sync; staleness OK
 // writeObject writes a Hashtable<Class<?>, PermissionCollection> for
 // the perms key, so this cast is safe, unless the data is corrupt.
 @SuppressWarnings("unchecked")
 Hashtable<Class<?>, PermissionCollection> perms =
 (Hashtable<Class<?>, PermissionCollection>)gfields.get("perms", null);
-permsMap = new HashMap<>(perms.size()*2);
+permsMap = new ConcurrentHashMap<>(perms.size()*2);
 permsMap.putAll(perms);
 // Set hasUnresolved
 UnresolvedPermissionCollection uc =
 (UnresolvedPermissionCollection) permsMap.get(UnresolvedPermission.class);
 {
 /**
 * Key and value are (same) permissions objects.
 * Not serialized; see serialization section at end of class.
 */
-private transient Map<Permission, Permission> permsMap;
+private transient ConcurrentHashMap<Permission, Permission> permsMap;
 /**
 * Create an empty PermissionsHash object.
 */
 PermissionsHash() {
-permsMap = new HashMap<>(11);
+permsMap = new ConcurrentHashMap<>(11);
 }
 /**
 * Adds a permission to the PermissionsHash.
 *
 * @param permission the Permission object to add.
 */
+@Override
 public void add(Permission permission) {
-synchronized (this) {
+permsMap.put(permission, permission);
-permsMap.put(permission, permission);
-}
 }
 /**
 * Check and see if this set of permissions implies the permissions
 * expressed in "permission".
 * @param permission the Permission object to compare
 *
 * @return true if "permission" is a proper subset of a permission in
 * the set, false if not.
 */
+@Override
 public boolean implies(Permission permission) {
 // attempt a fast lookup and implies. If that fails
 // then enumerate through all the permissions.
-synchronized (this) {
+Permission p = permsMap.get(permission);
-Permission p = permsMap.get(permission);
+// If permission is found, then p.equals(permission)
-// If permission is found, then p.equals(permission)
+if (p == null) {
-if (p == null) {
+for (Permission p_ : permsMap.values()) {
-for (Permission p_ : permsMap.values()) {
+if (p_.implies(permission))
-if (p_.implies(permission))
+return true;
-return true;
-}
-return false;
-} else {
-return true;
 }
+return false;
+} else {
+return true;
 }
 }
 /**
 * Returns an enumeration of all the Permission objects in the container.
 *
 * @return an enumeration of all the Permissions.
 */
+@Override
 public Enumeration<Permission> elements() {
-// Convert Iterator of Map values into an Enumeration
+return permsMap.elements();
-synchronized (this) {
-return Collections.enumeration(permsMap.values());
-}
 }
 private static final long serialVersionUID = -8491988220802933440L;
 // Need to maintain serialization interoperability with earlier releases,
 // which had the serializable field:
 // Don't call out.defaultWriteObject()
 // Copy perms into a Hashtable
 Hashtable<Permission, Permission> perms =
 new Hashtable<>(permsMap.size()*2);
-synchronized (this) {
+perms.putAll(permsMap);
-perms.putAll(permsMap);
-}
 // Write out serializable fields
 ObjectOutputStream.PutField pfields = out.putFields();
 pfields.put("perms", perms);
 out.writeFields();
 // writeObject writes a Hashtable<Class<?>, PermissionCollection> for
 // the perms key, so this cast is safe, unless the data is corrupt.
 @SuppressWarnings("unchecked")
 Hashtable<Permission, Permission> perms =
 (Hashtable<Permission, Permission>)gfields.get("perms", null);
-permsMap = new HashMap<>(perms.size()*2);
+permsMap = new ConcurrentHashMap<>(perms.size()*2);
 permsMap.putAll(perms);
 }
 }

changeset 31080	00a25f4c4d44
parent 30033	b9c86c17164a
child 31538	0981099a3e54