枚举单例

实现线程安全的单例的最简单方法是使用Enum：

public enum SingletonEnum {
  INSTANCE;
  public void doSomething(){
    System.out.println("This is a singleton");
  }
}

自从在Java 1.5中引入Enum以来，此代码一直有效

双重检查锁定

如果你想编写一个在多线程环境中工作的“经典”单例（从Java1.5开始），你应该使用这个。

public class Singleton {

  private static volatile Singleton instance = null;

  private Singleton() {
  }

  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class){
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

这在1.5之前不是线程安全的，因为volatile关键字的实现不同。

早期加载单例（甚至在Java1.5之前就可以使用）

这个实现在加载类时实例化单例，并提供线程安全性。

public class Singleton {

  private static final Singleton instance = new Singleton();

  private Singleton() {
  }

  public static Singleton getInstance() {
    return instance;
  }

  public void doSomething(){
    System.out.println("This is a singleton");
  }

}

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

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

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

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

Stu Thompson发布的解决方案在Java 5.0及更高版本中有效。但我宁愿不使用它，因为我认为它容易出错。

人们很容易忘记不稳定的说法，也很难理解为什么有必要这样做。如果没有易失性，由于双重检查锁定反模式，该代码将不再是线程安全的。有关这一点的更多信息，请参阅《Java并发实践》第16.2.4段。简而言之：此模式（在Java5.0之前或没有volatile语句）可能返回对Bar对象的引用，该对象（仍然）处于错误状态。

这种模式是为性能优化而发明的。但这真的不再是一个真正的问题了。下面的惰性初始化代码很快，更重要的是，更容易阅读。

class Bar {
    private static class BarHolder {
        public static Bar bar = new Bar();
    }

    public static Bar getBar() {
        return BarHolder.bar;
    }
}

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

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

实现单例有很多细微差别。夹持器图案不能在许多情况下使用。在使用volatile时，也应该使用局部变量。让我们从头开始，反复讨论这个问题。你会明白我的意思的。

第一次尝试可能看起来像这样：

public class MySingleton {

     private static MySingleton INSTANCE;

     public static MySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new MySingleton();
        }
        return INSTANCE;
    }
    ...
}

这里我们有一个MySingleton类，它有一个名为INSTANCE的私有静态成员和名为getInstance（）的公共静态方法。第一次调用getInstance（）时，INSTANCE成员为空。然后，流将进入创建条件，并创建MySingleton类的新实例。对getInstance（）的后续调用将发现INSTANCE变量已设置，因此不会创建另一个MySingleton实例。这确保只有一个MySingleton实例在getInstance（）的所有调用方之间共享。

但这种实现有一个问题。多线程应用程序在创建单个实例时具有竞争条件。如果多个执行线程同时（或前后）命中getInstance（）方法，它们将分别将INSTANCE成员视为null。这将导致每个线程创建一个新的MySingleton实例，然后设置instance成员。

private static MySingleton INSTANCE;

public static synchronized MySingleton getInstance() {
    if (INSTANCE == null) {
        INSTANCE = new MySingleton();
    }
    return INSTANCE;
}

这里我们在方法签名中使用了synchronized关键字来同步getInstance（）方法。这肯定会修复我们的种族状况。线程现在将一次一个地阻塞并进入方法。但这也造成了性能问题。这个实现不仅同步了单个实例的创建；它同步对getInstance（）的所有调用，包括读取。读取不需要同步，因为它们只需返回INSTANCE的值。由于读取将构成我们调用的大部分（记住，实例化只发生在第一次调用上），因此通过同步整个方法，我们将导致不必要的性能损失。

private static MySingleton INSTANCE;

public static MySingleton getInstance() {
    if (INSTANCE == null) {
        synchronize(MySingleton.class) {
            INSTANCE = new MySingleton();
        }
    }
    return INSTANCE;
}

在这里，我们将同步从方法签名移到了一个同步块，该块包装MySingleton实例的创建。但这能解决我们的问题吗？嗯，我们不再阻止读取，但我们也后退了一步。多个线程将同时或几乎同时命中getInstance（）方法，它们都会将INSTANCE成员视为空。

然后，它们将到达同步块，在那里将获得锁并创建实例。当该线程退出块时，其他线程将争夺锁，每个线程将逐一通过块并创建我们类的新实例。所以我们回到了我们开始的地方。

private static MySingleton INSTANCE;

public static MySingleton getInstance() {
    if (INSTANCE == null) {
        synchronized(MySingleton.class) {
            if (INSTANCE == null) {
                INSTANCE = createInstance();
            }
        }
    }
    return INSTANCE;
}

在这里，我们从区块内部发出另一张支票。如果INSTANCE成员已经设置，我们将跳过初始化。这称为双重检查锁定。

这解决了我们的多重实例化问题。但我们的解决方案再次提出了另一个挑战。其他线程可能无法“看到”INSTANCE成员已更新。这是因为Java如何优化内存操作。

线程将变量的原始值从主内存复制到CPU的缓存中。然后，对值的更改将写入该缓存并从中读取。这是Java的一个旨在优化性能的特性。但这给我们的单例实现带来了一个问题。第二个线程 — 由不同的CPU或内核使用不同的缓存进行处理 — 不会看到第一个所做的更改。这将导致第二个线程将INSTANCE成员视为空，从而强制创建单例的新实例。

private static volatile MySingleton INSTANCE;

public static MySingleton getInstance() {
    if (INSTANCE == null) {
        synchronized(MySingleton.class) {
            if (INSTANCE == null) {
                INSTANCE = createInstance();
            }
        }
    }
    return INSTANCE;
}

我们通过在INSTANCE成员的声明上使用volatile关键字来解决这个问题。这将告诉编译器始终读取和写入主内存，而不是CPU缓存。

但这种简单的改变是有代价的。因为我们绕过了CPU缓存，所以每次对易失性INSTANCE成员进行操作时，我们都会受到性能影响 — 我们做了四次。我们再次检查存在性（1和2），设置值（3），然后返回值（4）。有人可能会说，这条路径是边缘情况，因为我们只在方法的第一次调用期间创建实例。也许创作上的表现是可以容忍的。但即使是我们的主要用例reads，也会对volatile成员进行两次操作。一次检查是否存在，再次返回其值。

private static volatile MySingleton INSTANCE;

public static MySingleton getInstance() {
    MySingleton result = INSTANCE;
    if (result == null) {
        synchronized(MySingleton.class) {
            result = INSTANCE;
            if (result == null) {
                INSTANCE = result = createInstance();
            }
        }
    }
    return result;
}

由于性能受到影响是由于直接对volatile成员进行操作，所以让我们将一个局部变量设置为volatile的值，并改为对局部变量进行操作。这将减少我们在易失性上操作的次数，从而收回一些损失的性能。注意，当我们进入同步块时，必须再次设置本地变量。这确保了它是最新的，以及在我们等待锁时发生的任何更改。

我最近写了一篇关于这个的文章。解构单身汉。您可以在那里找到有关这些示例和“持有者”模式示例的更多信息。还有一个真实的例子展示了双重检查的易失性方法。

以下是三种不同的方法

枚举/***使用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；}}