如何统计实例创建次数？实例超限创建控制代码是否为最佳实践？

一、统计实例创建次数的核心思路 #

用静态变量记录实例总数是最直接的方式——因为静态变量属于类本身，所有实例共享。关键要保证多线程下的线程安全，否则并发创建实例时会出现计数错误。

二、你的代码：是否合理？有没有绕过的可能？ #

现有代码的可取之处 #

你用实例初始化块配合synchronized(Foo.class)做线程安全的计数，还加了volatile修饰count，这两点能保证多线程下计数准确。而且不管有多少个构造方法，初始化块都会自动执行，避免了重复写计数逻辑的麻烦，这点考虑得不错。

潜在的绕过场景 #

• 反序列化漏洞：如果你的类实现了Serializable接口，反序列化创建实例时，不会执行构造方法和实例初始化块，直接通过底层反射重建对象，count根本不会递增，完全绕过数量限制。
• Unsafe类直接创建实例：通过sun.misc.Unsafe的allocateInstance()方法可以直接分配对象内存，跳过所有构造逻辑和初始化块，直接生成实例，计数逻辑完全失效。这种方式一般用于底层框架，但如果有人刻意利用，就能绕开限制。

优化建议：更稳妥的实现方式 #

1. 改用工厂模式+私有构造

把构造方法设为私有，只通过工厂方法创建实例，彻底控制实例创建的入口：

public class Foo {
    private static volatile int count = 0;
    private static final int MAX_INSTANCES = 10;

    // 私有构造，禁止外部直接调用
    private Foo() {}
    private Foo(String arg) {}

    // 无参实例工厂
    public static Foo create() {
        synchronized (Foo.class) {
            if (count >= MAX_INSTANCES) {
                throw new RuntimeException("实例数量不能超过10个");
            }
            count++;
            return new Foo();
        }
    }

    // 带参数实例工厂
    public static Foo create(String arg) {
        synchronized (Foo.class) {
            if (count >= MAX_INSTANCES) {
                throw new RuntimeException("实例数量不能超过10个");
            }
            count++;
            return new Foo(arg);
        }
    }
}

这种方式把计数检查和实例创建绑定在一起，外部无法直接调用构造方法，从根源上减少了绕过的可能。

2. 处理序列化场景（如果需要序列化）

如果类必须实现Serializable，重写readResolve()方法，在反序列化时做计数检查：

private Object readResolve() throws ObjectStreamException {
    synchronized (Foo.class) {
        if (count >= MAX_INSTANCES) {
            throw new RuntimeException("实例数量超过限制，反序列化失败");
        }
        count++;
        return this;
    }
}

3. 用原子类优化并发逻辑（可选）

如果是高并发场景，可以用AtomicInteger替代volatile int，通过CAS操作减少锁竞争：

private static final AtomicInteger count = new AtomicInteger(0);
private static final int MAX_INSTANCES = 10;

// 工厂方法里的逻辑
public static Foo create() {
    while (true) {
        int current = count.get();
        if (current >= MAX_INSTANCES) {
            throw new RuntimeException("实例数量不能超过10个");
        }
        // CAS原子更新计数
        if (count.compareAndSet(current, current + 1)) {
            return new Foo();
        }
    }
}

这种方式不需要synchronized，适合高并发下的性能需求，但代码稍微复杂一点。

总结 #

你的现有代码在普通业务场景下能正常工作，但存在被反序列化、Unsafe类绕过的风险。最佳实践是用工厂模式+私有构造，统一控制实例创建逻辑，同时根据是否需要序列化做额外处理。

内容的提问来源于stack exchange，提问作者user22713628