以下是三种不同的方法

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

版本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;
    }
}

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

如果需要惰性地加载类的实例变量，则需要双重检查习惯用法。如果需要惰性地加载静态变量或单例，则需要按需初始化持有者习惯用法。

此外，如果单例需要可序列化，则所有其他字段都需要是暂时的，并且需要实现readResolve（）方法以保持单例对象不变。否则，每次反序列化对象时，都会创建对象的新实例。readResolve（）所做的是用readObject（）替换读取的新对象，因为没有变量引用该对象，所以强制对该新对象进行垃圾回收。

public static final INSTANCE == ....
private Object readResolve() {
  return INSTANCE; // Original singleton instance.
} 

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

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

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

如果您不需要延迟加载，那么只需尝试：

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

    private Singleton() {}

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

    protected Object clone() {
        throw new CloneNotSupportedException();
    }
}

如果您希望延迟加载并且希望单例是线程安全的，请尝试双重检查模式：

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

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

    protected Object clone() {
        throw new CloneNotSupportedException();
    }
}

由于双重检查模式不能保证有效（由于编译器的一些问题，我对此一无所知），因此您也可以尝试同步整个getInstance方法或为所有单例创建注册表。