Java GcFinalization类代码示例

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testFinalizeDeletesFile() throws Exception {
  byte[] data = newPreFilledByteArray(100);
  FileBackedOutputStream out = new FileBackedOutputStream(0, true);

  write(out, data, 0, 100, true);
  final File file = out.getFile();
  assertEquals(100, file.length());
  assertTrue(file.exists());
  out.close();

  // Make sure that finalize deletes the file
  out = null;

  // times out and throws RuntimeException on failure
  GcFinalization.awaitDone(new GcFinalization.FinalizationPredicate() {
    @Override
    public boolean isDone() {
      return !file.exists();
    }
  });
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
@AndroidIncompatible // reference is never cleared under some versions of the emulator
@GwtIncompatible
public void testInputGCedIfUnreferenced() throws Exception {
  SettableFuture<Long> future1 = SettableFuture.create();
  SettableFuture<Long> future2 = SettableFuture.create();
  WeakReference<SettableFuture<Long>> future1Ref = new WeakReference<>(future1);
  WeakReference<SettableFuture<Long>> future2Ref = new WeakReference<>(future2);

  ImmutableList<ListenableFuture<Long>> delegates =
      inCompletionOrder(ImmutableList.<ListenableFuture<Long>>of(future1, future2));

  future1.set(1L);

  future1 = null;
  // First future is complete, should be unreferenced
  GcFinalization.awaitClear(future1Ref);
  ListenableFuture<Long> outputFuture1 = delegates.get(0);
  delegates = null;
  future2 = null;
  // No references to list or other output future, second future should be unreferenced
  GcFinalization.awaitClear(future2Ref);
  outputFuture1.get();
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testFinalizeDeletesFile() throws Exception {
  byte[] data = newPreFilledByteArray(100);
  FileBackedOutputStream out = new FileBackedOutputStream(0, true);

  write(out, data, 0, 100, true);
  final File file = out.getFile();
  assertEquals(100, file.length());
  assertTrue(file.exists());
  out.close();

  // Make sure that finalize deletes the file
  out = null;

  // times out and throws RuntimeException on failure
  GcFinalization.awaitDone(
      new GcFinalization.FinalizationPredicate() {
        @Override
        public boolean isDone() {
          return !file.exists();
        }
      });
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testProxyClassUnloading() {
  Object testObject =
      Guice.createInjector(interceptorModule, testModule).getInstance(proxyTestClass);
  assertNotNull(testObject.getClass().getClassLoader());
  assertNotSame(testObject.getClass().getClassLoader(), systemClassLoader);

  // take a weak reference to the generated proxy class
  WeakReference<Class<?>> clazzRef = new WeakReference<Class<?>>(testObject.getClass());

  assertNotNull(clazzRef.get());

  // null the proxy
  testObject = null;

  /*
   * this should be enough to queue the weak reference
   * unless something is holding onto it accidentally.
   */
  GcFinalization.awaitClear(clazzRef);

  // This test could be somewhat flaky when the GC isn't working.
  // If it fails, run the test again to make sure it's failing reliably.
  assertNull("Proxy class was not unloaded.", clazzRef.get());
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
@Test
public void invalidatedValuesAreGCedAsExpected() throws Exception {
  SkyKey key = GraphTester.skyKey("a");
  HeavyValue heavyValue = new HeavyValue();
  WeakReference<HeavyValue> weakRef = new WeakReference<>(heavyValue);
  tester.set("a", heavyValue);

  graph = new InMemoryGraphImpl();
  eval(false, key);
  invalidate(graph, new DirtyTrackingProgressReceiver(null), key);

  tester = null;
  heavyValue = null;
  if (gcExpected()) {
    GcFinalization.awaitClear(weakRef);
  } else {
    // Not a reliable check, but better than nothing.
    System.gc();
    Thread.sleep(300);
    assertThat(weakRef.get()).isNotNull();
  }
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
@Test
public void deleteInvalidatedValue() throws Exception {
  initializeTester();
  SkyKey top = GraphTester.toSkyKey("top");
  SkyKey toDelete = GraphTester.toSkyKey("toDelete");
  // Must be a concatenation -- COPY doesn't actually copy.
  tester.getOrCreate(top).addDependency(toDelete).setComputedValue(CONCATENATE);
  tester.set(toDelete, new StringValue("toDelete"));
  SkyValue value = tester.evalAndGet("top");
  SkyKey forceInvalidation = GraphTester.toSkyKey("forceInvalidation");
  tester.set(forceInvalidation, new StringValue("forceInvalidation"));
  tester.getOrCreate(toDelete, /*markAsModified=*/true);
  tester.invalidate();
  tester.eval(/*keepGoing=*/false, forceInvalidation);
  tester.delete("toDelete");
  WeakReference<SkyValue> ref = new WeakReference<>(value);
  value = null;
  tester.eval(/*keepGoing=*/false, forceInvalidation);
  tester.invalidate(); // So that invalidation receiver doesn't hang on to reference.
  GcFinalization.awaitClear(ref);
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
private void testMultiThreadedUse(int numMainExceptions, int numSuppressedPerMain)
    throws InterruptedException {
  CountDownLatch latch = new CountDownLatch(numMainExceptions * numSuppressedPerMain);
  ConcurrentWeakIdentityHashMap map =
      testFunctionalCorrectnessForMultiThreadedUse(
          numMainExceptions, numSuppressedPerMain, latch);
  /*
   * Calling the following methods multiple times to make sure the keys are garbage collected,
   * and their corresponding entries are removed from the map.
   */
  map.deleteEmptyKeys();
  GcFinalization.awaitFullGc();
  map.deleteEmptyKeys();
  GcFinalization.awaitFullGc();
  map.deleteEmptyKeys();

  assertThat(map.size()).isEqualTo(0);
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testWeakKeySet_integration_mapbinder() {
  Key<Map<String, String>> mapKey = Key.get(new TypeLiteral<Map<String, String>>() {});
  
  Injector parentInjector = Guice.createInjector(new AbstractModule() {
        @Override protected void configure() {
          bind(String.class).toInstance("hi");
        }
      });
  WeakKeySetUtils.assertNotBlacklisted(parentInjector, mapKey);

  Injector childInjector = parentInjector.createChildInjector(new AbstractModule() {
    @Override protected void configure() {
      MapBinder<String, String> binder =
          MapBinder.newMapBinder(binder(), String.class, String.class);
      binder.addBinding("bar").toInstance("foo");
    }
  });
  WeakReference<Injector> weakRef = new WeakReference<Injector>(childInjector);
  WeakKeySetUtils.assertBlacklisted(parentInjector, mapKey);
  
  // Clear the ref, GC, and ensure that we are no longer blacklisting.
  childInjector = null;
  
  GcFinalization.awaitClear(weakRef);
  WeakKeySetUtils.assertNotBlacklisted(parentInjector, mapKey);
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testWeakKeySet_integration() {   
  Injector parentInjector = Guice.createInjector(new AbstractModule() {
        @Override protected void configure() {
          bind(String.class).toInstance("hi");
        }
      });
  WeakKeySetUtils.assertNotBlacklisted(parentInjector, Key.get(Integer.class));

  Injector childInjector = parentInjector.createChildInjector(new AbstractModule() {
    @Override protected void configure() {
      OptionalBinder.newOptionalBinder(binder(), Integer.class).setDefault().toInstance(4);
    }
  });
  WeakReference<Injector> weakRef = new WeakReference<Injector>(childInjector);
  WeakKeySetUtils.assertBlacklisted(parentInjector, Key.get(Integer.class));
  
  // Clear the ref, GC, and ensure that we are no longer blacklisting.
  childInjector = null;
  
  GcFinalization.awaitClear(weakRef);
  WeakKeySetUtils.assertNotBlacklisted(parentInjector, Key.get(Integer.class));
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testEviction() {
  TestState state = new TestState();
  Key<Integer> key = Key.get(Integer.class);
  Object source = new Object();
  
  WeakReference<Key<Integer>> weakKeyRef = new WeakReference<Key<Integer>>(key);

  set.add(key, state, source);
  assertTrue(set.contains(key));
  assertEquals(1, set.getSources(key).size());
  assertTrue(set.getSources(key).contains(source));

  state = null;

  GcFinalization.awaitFullGc();

  assertFalse(set.contains(Key.get(Integer.class)));
  assertNull(set.getSources(Key.get(Integer.class)));

  // Ensure there are no hanging references.
  key = null;
  GcFinalization.awaitClear(weakKeyRef);
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testEviction_nullSource() {
  TestState state = new TestState();
  Key<Integer> key = Key.get(Integer.class);
  Object source = null;
  
  WeakReference<Key<Integer>> weakKeyRef = new WeakReference<Key<Integer>>(key);

  set.add(key, state, source);
  assertTrue(set.contains(key));
  assertEquals(1, set.getSources(key).size());
  assertTrue(set.getSources(key).contains(source));

  state = null;

  GcFinalization.awaitFullGc();

  assertFalse(set.contains(Key.get(Integer.class)));
  assertNull(set.getSources(Key.get(Integer.class)));

  // Ensure there are no hanging references.
  key = null;
  GcFinalization.awaitClear(weakKeyRef);
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testWeakKeySet_integration() {
  Injector parentInjector = Guice.createInjector(new AbstractModule() {
        @Override protected void configure() {
          bind(Integer.class).toInstance(4);
        }
      });
  assertNotBlacklisted(parentInjector, Key.get(String.class));

  Injector childInjector = parentInjector.createChildInjector(new AbstractModule() {
    @Override protected void configure() {
      bind(String.class).toInstance("bar");
    }
  });
  WeakReference<Injector> weakRef = new WeakReference<Injector>(childInjector);
  assertBlacklisted(parentInjector, Key.get(String.class));
  
  // Clear the ref, GC, and ensure that we are no longer blacklisting.
  childInjector = null;
  GcFinalization.awaitClear(weakRef);
  assertNotBlacklisted(parentInjector, Key.get(String.class));
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
@GwtIncompatible // weak references
public void testFreesNextReference() {
  Iterator<Object> itr = new AbstractIterator<Object>() {
    @Override public Object computeNext() {
      return new Object();
    }
  };
  WeakReference<Object> ref = new WeakReference<Object>(itr.next());
  GcFinalization.awaitClear(ref);
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
public void testUnloadableInStaticFieldIfClosed() throws Exception {
  Policy oldPolicy = Policy.getPolicy();
  SecurityManager oldSecurityManager = System.getSecurityManager();
  try {
    Policy.setPolicy(new PermissivePolicy());
    System.setSecurityManager(new SecurityManager());
    WeakReference<ClassLoader> loaderRef = doTestUnloadableInStaticFieldIfClosed();
    GcFinalization.awaitClear(loaderRef);
  } finally {
    System.setSecurityManager(oldSecurityManager);
    Policy.setPolicy(oldPolicy);
  }
}
 

import com.google.common.testing.GcFinalization; //导入依赖的package包/类
private WeakReference<ClassLoader> doTestUnloadableInStaticFieldIfClosed() throws Exception {
  final URLClassLoader myLoader = (URLClassLoader) getClass().getClassLoader();
  final URL[] urls = myLoader.getURLs();
  URLClassLoader sepLoader = new URLClassLoader(urls, myLoader.getParent());

  Class<?> frqC = FinalizableReferenceQueue.class;
  Class<?> sepFrqC = sepLoader.loadClass(frqC.getName());
  assertNotSame(frqC, sepFrqC);

  Class<?> sepFrqSystemLoaderC =
      sepLoader.loadClass(FinalizableReferenceQueue.SystemLoader.class.getName());
  Field disabled = sepFrqSystemLoaderC.getDeclaredField("disabled");
  disabled.setAccessible(true);
  disabled.set(null, true);

  Class<?> frqUserC = FrqUser.class;
  Class<?> sepFrqUserC = sepLoader.loadClass(frqUserC.getName());
  assertNotSame(frqUserC, sepFrqUserC);
  assertSame(sepLoader, sepFrqUserC.getClassLoader());

  Callable<?> sepFrqUser = (Callable<?>) sepFrqUserC.newInstance();
  WeakReference<?> finalizableWeakReference = (WeakReference<?>) sepFrqUser.call();

  GcFinalization.awaitClear(finalizableWeakReference);

  Field sepFrqUserFinalizedF = sepFrqUserC.getField("finalized");
  Semaphore finalizeCount = (Semaphore) sepFrqUserFinalizedF.get(null);
  boolean finalized = finalizeCount.tryAcquire(5, TimeUnit.SECONDS);
  assertTrue(finalized);

  Field sepFrqUserFrqF = sepFrqUserC.getField("frq");
  Closeable frq = (Closeable) sepFrqUserFrqF.get(null);
  frq.close();

  return new WeakReference<ClassLoader>(sepLoader);
}