单例中的线程安全

Question

我知道 Java 中的双重锁定已被破坏，那么在 Java 中使单例线程安全的最佳方法是什么？我首先想到的是：

class Singleton{
    private static Singleton instance;

    private Singleton(){}

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

这行得通吗？如果是这样，这是最好的方法吗（我想这取决于具体情况，所以说明什么时候一种特定的技术是最好的，会很有用）

Answer 1

Josh Bloch 建议使用单元素 enum 类型来实现单例（请参阅Effective Java 2nd Edition，第 3 项：使用私有构造函数或枚举类型强制单例属性）。

有些人认为这是一种 hack，因为它没有清楚地传达意图，但它确实有效。

以下示例直接取自本书。

public enum Elvis {
   INSTANCE;

   public void leaveTheBuilding() { ... }
}

这是他的结束论点：

这种方法 [...] 更简洁，免费提供序列化机制，并提供针对多个实例化的铁定保证，即使面对复杂的序列化或反射攻击。虽然这种方法尚未被广泛采用，但单元素枚举类型是实现单例的最佳方式。

---

开启enum 常量单例保证

JLS 8.9. Enums

枚举类型除了由其枚举常量定义的实例外，没有其他实例。尝试显式实例化枚举类型（第 15.9.1 节）是编译时错误。

Enum 中的final clone 方法确保永远不会克隆枚举常量，并且序列化机制的特殊处理确保永远不会由于反序列化而创建重复实例。禁止枚举类型的反射实例化。这四件事一起确保枚举类型的实例不存在超出枚举常量定义的实例。

---

关于延迟初始化

下面的sn-p：

public class LazyElvis {
    enum Elvis {
        THE_ONE;
        Elvis() {
            System.out.println("I'M STILL ALIVE!!!");
        }       
    }
    public static void main(String[] args) {
        System.out.println("La-dee-daaa...");
        System.out.println(Elvis.THE_ONE);
    }
}

产生以下输出：

La-dee-daaa...
I'M STILL ALIVE!!!
THE_ONE

如您所见，THE_ONE 常量直到第一次被访问时才通过构造函数实例化。

Answer 2

我认为你的实现没有问题（除了单例监视器的锁可能被其他方法使用，出于其他原因，因此，不必要地阻止其他线程获取实例）。这可以通过引入额外的Object lock 来锁定来避免。

This Wikipedia article 建议另一种方法：

public class Something {
    private Something() {
    }

    private static class LazyHolder {
        private static final Something INSTANCE = new Something();
    }

    public static Something getInstance() {
        return LazyHolder.INSTANCE;
    }
}

来自文章：

此实现是一个性能良好的并发实现，适用于所有 Java 版本。
...
该实现依赖于 Java 虚拟机 (JVM) 中明确指定的执行初始化阶段；有关详细信息，请参阅 Java 语言规范 (JLS) 的第 12.4 节。

Answer 3

我的偏好是做：

class Singleton {
    private static final INSTANCE = new Singleton();

    private Singleton(){}

    public Singleton instance(){
        return INSTANCE;
    }
 }

很少需要延迟初始化。您应该始终从急切初始化开始，只有在发现问题时才更改为延迟初始化。除非您已经测量并确定单例实例化是性能问题的罪魁祸首，否则请使用急切初始化。它更简单，性能更高。

您当然可以使用枚举，但我个人并不介意，因为与普通急切实例化相比的好处是安全性（防止反射攻击），而且大多数时候我的代码无论如何都容易受到此类攻击：p

Answer 4

Josh Bloch 推荐了 2 个解决方案：

1) 更糟：

class Singleton {

   public static Singleton instance = new Singleton();

   ...
}

2) 更好：

public enum Singleton {

   INSTANCE;

   ...
}

Answer 5

您可以使用 wiki 中的这个 sn-p 代码

public class Singleton {
   // Private constructor prevents instantiation from other classes
   private Singleton() {}

   /**
    * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
    * or the first access to SingletonHolder.INSTANCE, not before.
    */
   private static class SingletonHolder { 
     private static final Singleton INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
     return SingletonHolder.INSTANCE;
   }
 }