jdk-sandbox: comparison jdk/src/share/classes/sun/rmi/server/Activation.java

equal deleted inserted replaced

-:dbb0d972bf41
+:de183d393b77
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.ObjectInputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.io.Serializable;
 import java.lang.Process;
 import java.util.Map;
 import java.util.MissingResourceException;
 import java.util.Properties;
 import java.util.ResourceBundle;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import sun.rmi.log.LogHandler;
 import sun.rmi.log.ReliableLog;
 import sun.rmi.registry.RegistryImpl;
 import sun.rmi.runtime.NewThreadAction;
 import sun.rmi.server.UnicastServerRef;
 private static Method execPolicyMethod;
 private static boolean debugExec;
 /** maps activation id to its respective group id */
 private Map<ActivationID,ActivationGroupID> idTable =
-new HashMap<ActivationID,ActivationGroupID>();
+new ConcurrentHashMap<>();
 /** maps group id to its GroupEntry groups */
 private Map<ActivationGroupID,GroupEntry> groupTable =
-new HashMap<ActivationGroupID,GroupEntry>();
+new ConcurrentHashMap<>();
 private byte majorVersion = MAJOR_VERSION;
 private byte minorVersion = MINOR_VERSION;
 /** number of simultaneous group exec's */
 numUpdates = 0;
 shutdownHook =  new ShutdownHook();
 groupSemaphore = getInt("sun.rmi.activation.groupThrottle", 3);
 groupCounter = 0;
 Runtime.getRuntime().addShutdownHook(shutdownHook);
+// Use array size of 0, since the value from calling size()
+// may be out of date by the time toArray() is called.
 ActivationGroupID[] gids =
-groupTable.keySet().toArray(
+groupTable.keySet().toArray(new ActivationGroupID[0]);
-new ActivationGroupID[groupTable.size()]);
 synchronized (startupLock = new Object()) {
 // all the remote methods briefly synchronize on startupLock
 // (via checkShutdown) to make sure they don't happen in the
 // middle of this block.  This block must not cause any such
 e.printStackTrace();
 }
 }
 }
+/**
+* Previous versions used HashMap instead of ConcurrentHashMap.
+* Replace any HashMaps found during deserialization with
+* ConcurrentHashMaps.
+*/
+private void readObject(ObjectInputStream ois)
+throws IOException, ClassNotFoundException
+{
+ois.defaultReadObject();
+if (! (groupTable instanceof ConcurrentHashMap)) {
+groupTable = new ConcurrentHashMap<>(groupTable);
+}
+if (! (idTable instanceof ConcurrentHashMap)) {
+idTable = new ConcurrentHashMap<>(idTable);
+}
+}
 private static class SystemRegistryImpl extends RegistryImpl {
 private static final String NAME = ActivationSystem.class.getName();
 private final ActivationSystem systemStub;
 checkArgs(desc, null);
 ActivationGroupID id = new ActivationGroupID(systemStub);
 GroupEntry entry = new GroupEntry(id, desc);
 // table insertion must take place before log update
-synchronized (groupTable) {
+groupTable.put(id, entry);
-groupTable.put(id, entry);
-}
 addLogRecord(new LogRegisterGroup(id, desc));
 return id;
 }
 public ActivationMonitor activeGroup(ActivationGroupID id,
 checkShutdown();
 RegistryImpl.checkAccess("ActivationSystem.unregisterGroup");
 // remove entry before unregister so state is updated before
 // logged
-synchronized (groupTable) {
+removeGroupEntry(id).unregisterGroup(true);
-GroupEntry entry = getGroupEntry(id);
-groupTable.remove(id);
-entry.unregisterGroup(true);
-}
 }
 public ActivationDesc setActivationDesc(ActivationID id,
 ActivationDesc desc)
 throws ActivationException, UnknownObjectException, RemoteException
 */
 unexport(activator);
 unexport(system);
 // destroy all child processes (groups)
-GroupEntry[] groupEntries;
+for (GroupEntry groupEntry : groupTable.values()) {
-synchronized (groupTable) {
-groupEntries = groupTable.values().
-toArray(new GroupEntry[groupTable.size()]);
-}
-for (GroupEntry groupEntry : groupEntries) {
 groupEntry.shutdown();
 }
 Runtime.getRuntime().removeShutdownHook(shutdownHook);
 synchronized (Activation.this) {
 shuttingDown = true;
 }
 // destroy all child processes (groups) quickly
-synchronized (groupTable) {
+for (GroupEntry groupEntry : groupTable.values()) {
-for (GroupEntry groupEntry : groupTable.values()) {
+groupEntry.shutdownFast();
-groupEntry.shutdownFast();
-}
 }
 }
 }
 /**
 * Throws UnknownObjectException if the object is not registered.
 */
 private ActivationGroupID getGroupID(ActivationID id)
 throws UnknownObjectException
 {
-synchronized (idTable) {
+ActivationGroupID groupID = idTable.get(id);
-ActivationGroupID groupID = idTable.get(id);
+if (groupID != null) {
-if (groupID != null) {
+return groupID;
-return groupID;
-}
 }
 throw new UnknownObjectException("unknown object: " + id);
+}
+/**
+* Returns the group entry for the group id, optionally removing it.
+* Throws UnknownGroupException if the group is not registered.
+*/
+private GroupEntry getGroupEntry(ActivationGroupID id, boolean rm)
+throws UnknownGroupException
+{
+if (id.getClass() == ActivationGroupID.class) {
+GroupEntry entry;
+if (rm) {
+entry = groupTable.remove(id);
+} else {
+entry = groupTable.get(id);
+}
+if (entry != null && !entry.removed) {
+return entry;
+}
+}
+throw new UnknownGroupException("group unknown");
 }
 /**
 * Returns the group entry for the group id. Throws
 * UnknownGroupException if the group is not registered.
 */
 private GroupEntry getGroupEntry(ActivationGroupID id)
 throws UnknownGroupException
 {
-if (id.getClass() == ActivationGroupID.class) {
+return getGroupEntry(id, false);
-synchronized (groupTable) {
+}
-GroupEntry entry = groupTable.get(id);
-if (entry != null && !entry.removed) {
+/**
-return entry;
+* Removes and returns the group entry for the group id. Throws
-}
+* UnknownGroupException if the group is not registered.
-}
+*/
-}
+private GroupEntry removeGroupEntry(ActivationGroupID id)
-throw new UnknownGroupException("group unknown");
+throws UnknownGroupException
+{
+return getGroupEntry(id, true);
 }
 /**
 * Returns the group entry for the object's id. Throws
 * UnknownObjectException if the object is not registered or the
 */
 private GroupEntry getGroupEntry(ActivationID id)
 throws UnknownObjectException
 {
 ActivationGroupID gid = getGroupID(id);
-synchronized (groupTable) {
+GroupEntry entry = groupTable.get(gid);
-GroupEntry entry = groupTable.get(gid);
+if (entry != null && !entry.removed) {
-if (entry != null) {
+return entry;
-return entry;
-}
 }
 throw new UnknownObjectException("object's group removed");
 }
 /**
 if (desc.getRestartMode() == true) {
 restartSet.add(id);
 }
 // table insertion must take place before log update
-synchronized (idTable) {
+idTable.put(id, groupID);
-idTable.put(id, groupID);
-}
 if (addRecord) {
 addLogRecord(new LogRegisterObject(id, desc));
 }
 }
 objects.remove(id);
 if (objEntry.desc.getRestartMode() == true) {
 restartSet.remove(id);
 }
-// table insertion must take place before log update
+// table removal must take place before log update
-synchronized (idTable) {
+idTable.remove(id);
-idTable.remove(id);
-}
 if (addRecord) {
 addLogRecord(new LogUnregisterObject(id));
 }
 }
 removed = true;
 for (Map.Entry<ActivationID,ObjectEntry> entry :
 objects.entrySet())
 {
 ActivationID id = entry.getKey();
-synchronized (idTable) {
+idTable.remove(id);
-idTable.remove(id);
-}
 ObjectEntry objEntry = entry.getValue();
 objEntry.removed = true;
 }
 objects.clear();
 restartSet.clear();

changeset 9502	de183d393b77
parent 5506	202f599c92aa
child 12040	558b0e0d5910