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

equal deleted inserted replaced

-:a6b5f444cb68
+:00a25f4c4d44
 * questions.
 */
 package java.security;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamField;
 import java.util.Enumeration;
-import java.util.Map;
-import java.util.HashMap;
 import java.util.Hashtable;
-import java.util.Collections;
+import java.util.concurrent.ConcurrentHashMap;
-import java.io.ObjectStreamField;
-import java.io.ObjectOutputStream;
-import java.io.ObjectInputStream;
-import java.io.IOException;
 /**
 * The BasicPermission class extends the Permission class, and
 * can be used as the base class for permissions that want to
 * follow the same naming convention as BasicPermission.
 * @param p the permission to check against.
 *
 * @return true if the passed permission is equal to or
 * implied by this permission, false otherwise.
 */
+@Override
 public boolean implies(Permission p) {
 if ((p == null) || (p.getClass() != getClass()))
 return false;
 BasicPermission that = (BasicPermission) p;
 *
 * @param obj the object we are testing for equality with this object.
 * @return true if {@code obj}'s class is the same as this object's class
 *  and has the same name as this BasicPermission object, false otherwise.
 */
+@Override
 public boolean equals(Object obj) {
 if (obj == this)
 return true;
 if ((obj == null) || (obj.getClass() != getClass()))
 * {@code getName().hashCode()}, where {@code getName} is
 * from the Permission superclass.
 *
 * @return a hash code value for this object.
 */
+@Override
 public int hashCode() {
 return this.getName().hashCode();
 }
 /**
 * which currently is the empty string "", since there are no actions for
 * a BasicPermission.
 *
 * @return the empty string "".
 */
+@Override
 public String getActions() {
 return "";
 }
 /**
 * to be implemented in an efficient (and consistent) manner.
 *
 * @return a new PermissionCollection object suitable for
 * storing BasicPermissions.
 */
+@Override
 public PermissionCollection newPermissionCollection() {
 return new BasicPermissionCollection(this.getClass());
 }
 /**
 /**
 * Key is name, value is permission. All permission objects in
 * collection must be of the same type.
 * Not serialized; see serialization section at end of class.
 */
-private transient Map<String, Permission> perms;
+private transient ConcurrentHashMap<String, Permission> perms;
 /**
 * This is set to {@code true} if this BasicPermissionCollection
 * contains a BasicPermission with '*' as its permission name.
 *
 */
 private boolean all_allowed;
 /**
 * The class to which all BasicPermissions in this
-* BasicPermissionCollection belongs.
+* BasicPermissionCollection belong.
 *
 * @see #serialPersistentFields
 */
 private Class<?> permClass;
 /**
 * Create an empty BasicPermissionCollection object.
 *
 */
 public BasicPermissionCollection(Class<?> clazz) {
-perms = new HashMap<>(11);
+perms = new ConcurrentHashMap<>(11);
 all_allowed = false;
 permClass = clazz;
 }
 /**
 *                                       permissions in this collection.
 *
 * @exception SecurityException - if this BasicPermissionCollection object
 *                                has been marked readonly
 */
+@Override
 public void add(Permission permission) {
 if (! (permission instanceof BasicPermission))
 throw new IllegalArgumentException("invalid permission: "+
 permission);
 if (isReadOnly())
 if (bp.getClass() != permClass)
 throw new IllegalArgumentException("invalid permission: " +
 permission);
 }
-synchronized (this) {
+String canonName = bp.getCanonicalName();
-perms.put(bp.getCanonicalName(), permission);
+perms.put(canonName, permission);
-}
 // No sync on all_allowed; staleness OK
 if (!all_allowed) {
-if (bp.getCanonicalName().equals("*"))
+if (canonName.equals("*"))
 all_allowed = true;
 }
 }
 /**
 * @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) {
 if (! (permission instanceof BasicPermission))
 return false;
 BasicPermission bp = (BasicPermission) permission;
 // path looking for matches on a.b..*
 String path = bp.getCanonicalName();
 //System.out.println("check "+path);
-Permission x;
+Permission x = perms.get(path);
-synchronized (this) {
-x = perms.get(path);
-}
 if (x != null) {
 // we have a direct hit!
 return x.implies(permission);
 }
 while ((last = path.lastIndexOf('.', offset)) != -1) {
 path = path.substring(0, last+1) + "*";
 //System.out.println("check "+path);
-synchronized (this) {
+x = perms.get(path);
-x = perms.get(path);
-}
 if (x != null) {
 return x.implies(permission);
 }
 offset = last -1;
 * Returns an enumeration of all the BasicPermission objects in the
 * container.
 *
 * @return an enumeration of all the BasicPermission objects.
 */
+@Override
 public Enumeration<Permission> elements() {
-// Convert Iterator of Map values into an Enumeration
+return perms.elements();
-synchronized (this) {
-return Collections.enumeration(perms.values());
-}
 }
 // Need to maintain serialization interoperability with earlier releases,
 // which had the serializable field:
 //
 // Copy perms into a Hashtable
 Hashtable<String, Permission> permissions =
 new Hashtable<>(perms.size()*2);
-synchronized (this) {
+permissions.putAll(perms);
-permissions.putAll(perms);
-}
 // Write out serializable fields
 ObjectOutputStream.PutField pfields = out.putFields();
 pfields.put("all_allowed", all_allowed);
 pfields.put("permissions", permissions);
 // writeObject writes a Hashtable<String, Permission> for the
 // permissions key, so this cast is safe, unless the data is corrupt.
 @SuppressWarnings("unchecked")
 Hashtable<String, Permission> permissions =
 (Hashtable<String, Permission>)gfields.get("permissions", null);
-perms = new HashMap<>(permissions.size()*2);
+perms = new ConcurrentHashMap<>(permissions.size()*2);
 perms.putAll(permissions);
 // Get all_allowed
 all_allowed = gfields.get("all_allowed", false);

changeset 31080	00a25f4c4d44
parent 30033	b9c86c17164a
child 45434	4582657c7260