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）推荐的方法，并且可以更好地进行论证。去阅读并投票支持他的答案。

版本1：

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

延迟加载，线程安全，阻塞，由于同步，性能低下。

版本2：

public class MySingleton {
    private MySingleton() {}
    private static class MySingletonHolder {
        public final static MySingleton instance = new MySingleton();
    }
    public static MySingleton getInstance() {
        return MySingletonHolder.instance;
    }
}

延迟加载，线程安全，无阻塞，高性能。

有时简单的“static Foo=new Foo（）；”是不够的。想想你想做的一些基本数据插入。

另一方面，您必须同步任何实例化单例变量的方法。同步本身并不坏，但它可能会导致性能问题或锁定（在非常罕见的情况下，使用本示例。解决方案是

public class Singleton {

    private static Singleton instance = null;

    static {
          instance = new Singleton();
          // do some of your instantiation stuff here
    }

    private Singleton() {
          if(instance!=null) {
                  throw new ErrorYouWant("Singleton double-instantiation, should never happen!");
          }
    }

    public static getSingleton() {
          return instance;
    }

}

现在会发生什么？类通过类加载器加载。在从字节数组解释类之后，VM立即执行静态{}-块。这就是全部秘密：静态块只被调用一次，即这个单类加载器加载给定包的给定类（名称）的时间。

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

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

创建单例对象的各种方法：

根据约书亚·布洛赫的说法，埃努姆将是最好的。也可以使用双重检查锁定。甚至可以使用内部静态类。

忘记延迟初始化；这太有问题了。这是最简单的解决方案：

public class A {    

    private static final A INSTANCE = new A();

    private A() {}

    public static A getInstance() {
        return INSTANCE;
    }
}