Java Reference.clear方法代码示例

import java.lang.ref.Reference; //导入方法依赖的package包/类
/**
 * Repeatedly dequeues references from the queue and invokes {@link
 * FinalizableReference#finalizeReferent()} on them until the queue is empty. This method is a
 * no-op if the background thread was created successfully.
 */
void cleanUp() {
  if (threadStarted) {
    return;
  }

  Reference<?> reference;
  while ((reference = queue.poll()) != null) {
    /*
     * This is for the benefit of phantom references. Weak and soft references will have already
     * been cleared by this point.
     */
    reference.clear();
    try {
      ((FinalizableReference) reference).finalizeReferent();
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
    }
  }
}
 

import java.lang.ref.Reference; //导入方法依赖的package包/类
/**
 * Repeatedly dequeues references from the queue and invokes
 * {@link FinalizableReference#finalizeReferent()} on them until the queue is empty. This method
 * is a no-op if the background thread was created successfully.
 */
void cleanUp() {
  if (threadStarted) {
    return;
  }

  Reference<?> reference;
  while ((reference = queue.poll()) != null) {
    /*
     * This is for the benefit of phantom references. Weak and soft references will have already
     * been cleared by this point.
     */
    reference.clear();
    try {
      ((FinalizableReference) reference).finalizeReferent();
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
    }
  }
}
 

import java.lang.ref.Reference; //导入方法依赖的package包/类
/**
 * Cleans up a single reference. Catches and logs all throwables.
 * @return true if the caller should continue, false if the associated FinalizableReferenceQueue
 * is no longer referenced.
 */
private boolean cleanUp(Reference<?> reference) {
  Method finalizeReferentMethod = getFinalizeReferentMethod();
  if (finalizeReferentMethod == null) {
    return false;
  }
  do {
    /*
     * This is for the benefit of phantom references. Weak and soft
     * references will have already been cleared by this point.
     */
    reference.clear();

    if (reference == frqReference) {
      /*
       * The client no longer has a reference to the
       * FinalizableReferenceQueue. We can stop.
       */
      return false;
    }

    try {
      finalizeReferentMethod.invoke(reference);
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
    }

    /*
     * Loop as long as we have references available so as not to waste
     * CPU looking up the Method over and over again.
     */
  } while ((reference = queue.poll()) != null);
  return true;
}
 

import java.lang.ref.Reference; //导入方法依赖的package包/类
/**
 * Cleans up a single reference. Catches and logs all throwables.
 *
 * @return true if the caller should continue, false if the associated FinalizableReferenceQueue
 *     is no longer referenced.
 */
private boolean cleanUp(Reference<?> reference) {
  Method finalizeReferentMethod = getFinalizeReferentMethod();
  if (finalizeReferentMethod == null) {
    return false;
  }
  do {
    /*
     * This is for the benefit of phantom references. Weak and soft references will have already
     * been cleared by this point.
     */
    reference.clear();

    if (reference == frqReference) {
      /*
       * The client no longer has a reference to the FinalizableReferenceQueue. We can stop.
       */
      return false;
    }

    try {
      finalizeReferentMethod.invoke(reference);
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
    }

    /*
     * Loop as long as we have references available so as not to waste CPU looking up the Method
     * over and over again.
     */
  } while ((reference = queue.poll()) != null);
  return true;
}
 

import java.lang.ref.Reference; //导入方法依赖的package包/类
/**
 * Poke into the Cache internals to simulate garbage collection of the value associated with the
 * given key. This assumes that the associated entry is a WeakValueReference or a
 * SoftValueReference (and not a LoadingValueReference), and throws an IllegalStateException
 * if that assumption does not hold.
 */
@SuppressWarnings("unchecked")  // the instanceof check and the cast generate this warning
static <K, V> void simulateValueReclamation(Cache<K, V> cache, K key) {
  ReferenceEntry<K, V> entry = getReferenceEntry(cache, key);
  if (entry != null) {
    ValueReference<K, V> valueRef = entry.getValueReference();
    // fail on strong/computing refs
    Preconditions.checkState(valueRef instanceof Reference);
    Reference<V> ref = (Reference<V>) valueRef;
    if (ref != null) {
      ref.clear();
    }
  }
}
 

import java.lang.ref.Reference; //导入方法依赖的package包/类
/**
 * Poke into the Cache internals to simulate garbage collection of the given key. This assumes
 * that the given entry is a weak or soft reference, and throws an IllegalStateException if that
 * assumption does not hold.
 */
@SuppressWarnings("unchecked")  // the instanceof check and the cast generate this warning
static <K, V> void simulateKeyReclamation(Cache<K, V> cache, K key) {
  ReferenceEntry<K, V> entry = getReferenceEntry(cache, key);

  Preconditions.checkState(entry instanceof Reference);
  Reference<?> ref = (Reference<?>) entry;
  if (ref != null) {
    ref.clear();
  }
}
 

import java.lang.ref.Reference; //导入方法依赖的package包/类
/********** test core **********/

    protected void runTests() throws Exception {
        targetClass = startToMain("ConstantPoolGCTarg").location().declaringType();

        if (vm().canGetConstantPool()) {
            byte[] cpbytes = targetClass.constantPool();

            // imitate SoftReference cleared
            Field constantPoolBytesRef = ReferenceTypeImpl.class.getDeclaredField("constantPoolBytesRef");
            constantPoolBytesRef.setAccessible(true);
            Reference softRef = (Reference) constantPoolBytesRef.get(targetClass);
            softRef.clear();

            byte[] cpbytes2 = targetClass.constantPool();
            if (!Arrays.equals(cpbytes, cpbytes2)) {
                failure("Consequent constantPool results vary, first was : " + cpbytes + ", now: " + cpbytes2);
            };

        } else {
            System.out.println("can get constant pool version not supported");
        }


        /*
         * resume until end
         */
        listenUntilVMDisconnect();

        /*
         * deal with results of test
         * if anything has called failure("foo") testFailed will be true
         */
        if (!testFailed) {
            println("ConstantPoolInfoGC: passed");
        } else {
            throw new Exception("ConstantPoolInfoGC: failed");
        }
    }