根据用法，有几个“正确”答案。

自Java5以来，最好的方法是使用枚举：

public enum Foo {
   INSTANCE;
}

在Java 5之前，最简单的情况是：

public final class Foo {

    private static final Foo INSTANCE = new Foo();

    private Foo() {
        if (INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return INSTANCE;
    }

    public Object clone() throws CloneNotSupportedException{
        throw new CloneNotSupportedException("Cannot clone instance of this class");
    }
}

让我们复习一下代码。首先，你希望这门课是期末考试。在本例中，我使用了final关键字来让用户知道它是final。然后，需要将构造函数设为私有，以防止用户创建自己的Foo。从构造函数中抛出异常会阻止用户使用反射来创建第二个Foo。然后创建一个私有的静态final Foo字段来保存唯一的实例，并创建一个公共的静态Foo-getInstance（）方法来返回它。Java规范确保只有在首次使用类时才调用构造函数。

当您有一个非常大的对象或大量的构造代码，并且还有其他可访问的静态方法或字段，这些方法或字段可能在需要实例之前使用，那么只有在需要时才需要使用惰性初始化。

您可以使用私有静态类来加载实例。代码将如下所示：

public final class Foo {

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

    private Foo() {
        if (FooLoader.INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }
}

由于行private static final Foo INSTANCE=new Foo（）；仅在实际使用FooLoader类时执行，这会处理延迟实例化，并保证线程安全。

当您还希望能够序列化对象时，需要确保反序列化不会创建副本。

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

    private Foo() {
        if (FooLoader.INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }

    @SuppressWarnings("unused")
    private Foo readResolve() {
        return FooLoader.INSTANCE;
    }
}

方法readResolve（）将确保返回唯一的实例，即使对象是在程序的上一次运行中序列化的。

对于JSE 5.0及以上版本，采用Enum方法。否则，使用静态单例持有者方法（Bill Pugh描述的一种延迟加载方法）。后一种解决方案也是线程安全的，不需要特殊的语言构造（即易失性或同步）。

我对一些答案感到困惑，这些答案建议依赖注入（DI）作为使用单态的替代方案；这些都是不相关的概念。您可以使用DI注入单例或非单例（例如，每个线程）实例。至少如果您使用Spring2.x，这是正确的，我不能为其他DI框架说话。

所以我对OP的回答是（除了最简单的示例代码之外）：

使用类似Spring framework的DI框架，然后将其作为DI配置的一部分，无论依赖项是单体的、请求范围的、会话范围的还是其他。

这种方法为您提供了一个很好的解耦（因此是灵活和可测试的）架构，其中是否使用单例是一个容易可逆的实现细节（当然，前提是您使用的任何单例都是线程安全的）。

在写它之前，真的要考虑一下为什么你需要一个单例。关于使用它们有一个准宗教的争论，如果你在Java中搜索单例，你很容易就会发现。

就我个人而言，出于许多原因，我尽量避免单身汉，其中大部分可以通过谷歌搜索单身汉找到。我觉得单身汉经常被虐待，因为他们很容易被每个人理解。它们被用作将“全局”数据引入OO设计的机制，因为它很容易绕过对象生命周期管理（或者真正思考如何从B内部实现a）。看看像控制反转（IoC）或依赖注入（DI）这样的事情，可以找到一个不错的中间地带。

如果你真的需要一个，那么Wikipedia有一个很好的例子来说明单例的正确实现。

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

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();
    }
}

我见过的最好的单例模式使用Supplier接口。

它是通用的，可重复使用它支持延迟初始化它只有在初始化之前才同步，然后将阻塞供应商替换为非阻塞供应商。

见下文：

public class Singleton<T> implements Supplier<T> {

    private boolean initialized;
    private Supplier<T> singletonSupplier;

    public Singleton(T singletonValue) {
        this.singletonSupplier = () -> singletonValue;
    }

    public Singleton(Supplier<T> supplier) {
        this.singletonSupplier = () -> {
            // The initial supplier is temporary; it will be replaced after initialization
            synchronized (supplier) {
                if (!initialized) {
                    T singletonValue = supplier.get();
                    // Now that the singleton value has been initialized,
                    // replace the blocking supplier with a non-blocking supplier
                    singletonSupplier = () -> singletonValue;
                    initialized = true;
                }
                return singletonSupplier.get();
            }
        };
    }

    @Override
    public T get() {
        return singletonSupplier.get();
    }
}