--- old/src/share/classes/sun/rmi/server/WeakClassHashMap.java
          +++ new/src/share/classes/sun/rmi/server/WeakClassHashMap.java

   1    1  /*
   2    2   * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.  Oracle designates this
   8    8   * particular file as subject to the "Classpath" exception as provided
   9    9   * by Oracle in the LICENSE file that accompanied this code.
  10   10   *
  11   11   * This code is distributed in the hope that it will be useful, but WITHOUT
  12   12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13   13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14   14   * version 2 for more details (a copy is included in the LICENSE file that
  15   15   * accompanied this code).
  16   16   *
  17   17   * You should have received a copy of the GNU General Public License version
  18   18   * 2 along with this work; if not, write to the Free Software Foundation,
  19   19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20   20   *
  21   21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22   22   * or visit www.oracle.com if you need additional information or have any
  23   23   * questions.
  24   24   */
  25   25  package sun.rmi.server;
  26   26  
  27   27  import java.lang.ref.Reference;
  28   28  import java.lang.ref.SoftReference;
  29   29  import java.util.Map;
  30   30  import java.util.WeakHashMap;
  31   31  
  32   32  /**
  33   33   * Abstract class that maps Class objects to lazily-computed values of
  34   34   * type V.  A concrete subclass must implement the computeValue method
  35   35   * to determine how the values are computed.
  36   36   *
  37   37   * The keys are only weakly reachable through this map, so this map
  38   38   * does not prevent a class (along with its class loader, etc.) from

  39   39   * being garbage collected if it is not otherwise strongly reachable.
  40   40   * The values are only softly reachable through this map, so that the
  41   41   * computed values generally persist while not otherwise strongly
  42   42   * reachable, but their storage may be reclaimed if necessary.  Also,
  43   43   * note that if a key is strongly reachable from a value, then the key
  44   44   * is effectively softly reachable through this map, which may delay
  45   45   * garbage collection of classes (see 4429536).
  46   46   **/
  47   47  public abstract class WeakClassHashMap<V> {
  48   48  
  49      -    private Map<Class<?>,ValueCell<V>> internalMap =
  50      -        new WeakHashMap<Class<?>,ValueCell<V>>();
       49 +    private Map<Class<?>,ValueCell<V>> internalMap = new WeakHashMap<>();
  51   50  
  52   51      protected WeakClassHashMap() { }
  53   52  
  54   53      public V get(Class<?> remoteClass) {
  55   54          /*
  56   55           * Use a mutable cell (a one-element list) to hold the soft
  57   56           * reference to a value, to allow the lazy value computation
  58   57           * to be synchronized with entry-level granularity instead of
  59   58           * by locking the whole table.
  60   59           */

  61   60          ValueCell<V> valueCell;
  62   61          synchronized (internalMap) {
  63   62              valueCell = internalMap.get(remoteClass);
  64   63              if (valueCell == null) {
  65   64                  valueCell = new ValueCell<V>();
  66   65                  internalMap.put(remoteClass, valueCell);
  67   66              }
  68   67          }
  69   68          synchronized (valueCell) {
  70   69              V value = null;
  71   70              if (valueCell.ref != null) {
  72   71                  value = valueCell.ref.get();
  73   72              }
  74   73              if (value == null) {
  75   74                  value = computeValue(remoteClass);
  76   75                  valueCell.ref = new SoftReference<V>(value);
  77   76              }
  78   77              return value;
  79   78          }
  80   79      }
  81   80  
  82   81      protected abstract V computeValue(Class<?> remoteClass);
  83   82  
  84   83      private static class ValueCell<T> {
  85   84          Reference<T> ref = null;
  86   85          ValueCell() { }
  87   86      }
  88   87  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX