如何在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创建美孚的多个实例。你必须以某种方式跟踪线程创建的实例数量。您可以使用ThreadLocal<Integer>这样做，然后在finally区块中调用decrementCounter()适当的次数。请参阅下面的完整工作示例。

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

最后一点，如果我是面试你的人，我试图让你意识到你提出的代码并不能完全满足要求：你必须使类final或方法incrementCount()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，并将它们收集在一个静态列表中。

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

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