如何在 Java 中实现对象计数器

Question

一位面试官问我

你如何实现一个 Foo 类，你可以在其中进行计数 该类的实例。有更多线程正在创建 该类 Foo 的实例。

我用下面的代码回复了

public class Foo {
    private static int count = 0;

    public Foo() {
    incrementCount();
    }

    public void incrementCount() {
        synchronize (Foo.class) {
            count++;
        }
    }
} 

她又问我了

如果一个线程结束，计数器应该递减，你怎么做？

我没有回答这个问题。

我知道finalize() 方法，但它取决于Garbage collector 何时调用此方法，即使我们覆盖finalize()。

我还没有解决办法，你能解释一下吗？

Answer 1

您可以将线程的 Runnable 包装在另一个 Runnable 中，这会减少计数器：

Thread createThread(final Runnable r) {
  return new Thread(new Runnable() {
    @Override public void run() {
      try {
        r.run();
      } finally {
        Foo.decrementCounter();
      }
    }
  });
}

这个问题是如果Runnable r 创建了多个 Foo 实例。您必须以某种方式跟踪线程创建了多少个实例。您可以使用ThreadLocal<Integer> 执行此操作，然后在finally 块中调用decrementCounter() 适当的次数。请参阅下面的完整工作示例。

如果你能避免它，你不应该依赖 GC 的行为，因为它是不可预测的！如果你坚持要处理垃圾收集器，那么你应该使用引用队列——为了正确使用它，你应该研究对象可达性的概念：http://docs.oracle.com/javase/7/docs/api/index.html?java/lang/ref/package-summary.html

作为最后一点，如果我在采访你，我会尽量让你意识到你提出的代码不能完全满足要求：你必须创建类final，或者方法@ 987654330@final 或private。或者，更简单的是，您可以在实例初始化程序块中增加计数：无需考虑在子类中被覆盖的方法或新添加的构造函数不会增加计数。

---

一个完整的例子：

public class Foo {
  private static final AtomicInteger liveInstances = new AtomicInteger(0);
  private static final ThreadLocal<Integer> threadLocalLiveInstances = new ThreadLocal<Integer>() {
    @Override protected Integer initialValue() { return 0; }
  }

  // instance initializer (so you won't have problems with multiple constructors or virtual methods called from them):
  {
    liveInstances.incrementAndGet();
    threadLocalLiveInstances.set(threadLocalLiveInstances.get() + 1);
  }

  public static int getTotalLiveInstances() {
    return liveInstances.get();
  }

  public static int getThreadLocalLiveInstances() {
    return threadLocalLiveInstances.get();
  }

  public static void decrementInstanceCount() {
    threadLocalLiveInstances.set(threadLocalLiveInstances.get() - 1);
    liveInstaces.decrementAndGet();
  }

  // ... rest of the code of the class ...
}

class FooCountingThreadFactory implements ThreadFactory {
  public Thread newThread(final Runnable r) {
    return new Thread(new Runnable() {
      @Override public void run() {
        try {
          r.run();
        } finally {
          while (Foo.getThreadLocalLiveInstances() > 0) {
            Foo.decrementInstanceCount();
          }
        }
      }
    });
  }
}

这样，您可以将此 ThreadFactory 提供给线程池，例如，或者您可以在要构建线程时自己使用它：(new FooCountingThreadFactory()).newThread(job);

无论如何，这种方法仍然存在一个问题：如果一个线程创建了Foo 的实例并将它们存储在全局范围内（阅读：static 字段），那么这些实例在线程死亡后仍然存在，并且计数器将全部减为0。

Answer 2

反过来做同样的事情。

由于 Sun (Oracle) 弃用了杀死线程 (Why are Thread. ... deprecated?) 的不安全方法，您的线程通过从其 run() 方法返回来“退出”。

只需在您的Foo 类中创建一个decrementCount() 方法，并确保在从您的线程中的run() 返回之前调用它。

由于 Java 中没有析构函数，而且正如您所指出的，finalize() 依赖于 GC……实际上并没有自动的方法来执行此操作。我能想到的唯一其他选择是创建/使用一个池，但这略有不同。

Answer 3

我想你也可以在构造函数中为新创建的实例创建一个新的SoftReference，并将它们收集到一个静态列表中。

如果你想要实例计数，你可以计算仍然存在的引用。

这样，当垃圾收集器完成其工作时，引用计数会减少。