另一个经常用来反对单态的论点是它们的可测试性问题。出于测试目的，单体不容易被模拟。如果这是一个问题，我想做以下轻微修改：

public class SingletonImpl {

    private static SingletonImpl instance;

    public static SingletonImpl getInstance() {
        if (instance == null) {
            instance = new SingletonImpl();
        }
        return instance;
    }

    public static void setInstance(SingletonImpl impl) {
        instance = impl;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

添加的setInstance方法允许在测试期间设置单例类的实体模型实现：

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

这也适用于早期初始化方法：

public class SingletonImpl {

    private static final SingletonImpl instance = new SingletonImpl();

    private static SingletonImpl alt;

    public static void setInstance(SingletonImpl inst) {
        alt = inst;
    }

    public static SingletonImpl getInstance() {
        if (alt != null) {
            return alt;
        }
        return instance;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

这有一个缺点，就是将此功能也暴露给普通应用程序。其他编写该代码的开发人员可能会尝试使用“setInstance”方法来更改特定函数，从而改变整个应用程序的行为，因此该方法的javadoc中至少应该包含一个良好的警告。

尽管如此，对于模型测试的可能性（当需要时），这种代码暴露可能是可以接受的代价。

有四种方法可以在Java中创建单例。

Eager初始化单例公共类测试{私有静态最终测试=新测试（）；专用测试（）{}公共静态测试getTest（）{回归试验；}}惰性初始化单例（线程安全）公共类测试{私人静态挥发性测试；专用测试（）{}公共静态测试getTest（）{if（测试==空）{同步（Test.class）{if（测试==空）{test=新测试（）；}}}回归试验；}}Bill Pugh单例与持有者模式（最好是最好的一个）公共类测试{专用测试（）{}私有静态类TestHolder{私有静态最终测试=新测试（）；}公共静态测试getInstance（）{return TestHolder.test；}}枚举单例公共枚举MySingleton{实例；私有MySingleton（）{System.out.println（“此处”）；}}

确保你真的需要它。在谷歌上搜索“singleton反模式”，看看反对它的一些论点。

我想这并没有什么本质上的问题，但它只是一种公开某些全局资源/数据的机制，因此请确保这是最好的方法。特别是，我发现依赖注入（DI）更有用，特别是如果您也在使用单元测试，因为DI允许您将模拟资源用于测试目的。

这是如何实现一个简单的单例：

public class Singleton {
    // It must be static and final to prevent later modification
    private static final Singleton INSTANCE = new Singleton();
    /** The constructor must be private to prevent external instantiation */
    private Singleton(){}
    /** The public static method allowing to get the instance */
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

这是如何正确地延迟创建单例：

public class Singleton {
    // The constructor must be private to prevent external instantiation
    private Singleton(){}
    /** The public static method allowing to get the instance */
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    /**
     * The static inner class responsible for creating your instance only on demand,
     * because the static fields of a class are only initialized when the class
     * is explicitly called and a class initialization is synchronized such that only
     * one thread can perform it, this rule is also applicable to inner static class
     * So here INSTANCE will be created only when SingletonHolder.INSTANCE
     * will be called
     */
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

Java 5+中的线程安全：

class Foo {
    private static volatile Bar bar = null;
    public static Bar getBar() {
        if (bar == null) {
            synchronized(Foo.class) {
                if (bar == null)
                    bar = new Bar();
            }
        }
        return bar;
    }
}

注意此处的挥发性修饰语。：）这很重要，因为如果没有它，JMM（Java内存模型）就不能保证其他线程看到其值的更改。同步不会处理这一点——它只序列化对该代码块的访问。

@Bno的回答详细介绍了Bill Pugh（FindBugs）推荐的方法，并且可以更好地进行论证。去阅读并投票支持他的答案。

以下是三种不同的方法

枚举/***使用Java Enum的Singleton模式示例*/公共枚举EasySingleton{实例；}双重检查锁定/延迟加载/***带有双重检查锁定的单线模式示例*/公共类DoubleCheckedLockingSingleton{私有静态易失性DoubleCheckedLockingSingleton INSTANCE；private DoubleCheckedLockingSingleton（）｛｝公共静态DoubleCheckedLockingSingleton getInstance（）{如果（INSTANCE==null）{synchronized（DoubleCheckedLockingSingleton.class）{//双重检查Singleton实例如果（INSTANCE==null）{INSTANCE=新的DoubleCheckedLockingSingleton（）；}}}返回INSTANCE；}}静态工厂方法/***带有静态工厂方法的Singleton模式示例*/公开课Singleton{//在类加载期间初始化private static final Singleton INSTANCE=new Singleton（）；//防止创建另一个“Singleton”实例私有Singleton（）｛｝公共静态Singleton getSingleton（）{返回INSTANCE；}}