概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

常见写法

饿汉式单例

在单例类首次加载时就创建单例

public class HungerSingleton{ private static final HungerSingleton instance =new HungerSingleton(); private HungerSingleton(){} public static HungerSingleton getInstance(){ return instance; } } 

缺点

• 浪费内存空间，不适合大量创建单例对象的场景

懒汉式单例

为了解决饿汉式单例可能带来的内存浪费的问题，提出了懒汉式单例。懒汉式单例的特点是：单例对象要在被使用时才会初始化。

线程不安全

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

缺点

• 线程不安全

线程安全

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

缺点

• 必须加锁 synchronized 才能保证单例，但加锁会影响效率。

双重检查锁

既能解决线程安全又能提升程序性能，提出了双重检查锁

class SynchronizedSingleton{ private static volatile SynchronizedSingleton instance =null; private SynchronizedSingleton(){} private static SynchronizedSingleton getInstance(){ if (instance==null){ synchronized (SynchronizedSingleton.class){ if (instance==null){ return new SynchronizedSingleton(); } } } return instance; } } 

缺点

• 总归还是用到了synchronized 加锁操作，影响性能

内部类实现

利用了内部类的加载方式：外部类初始化的时候内部类不会加载，只要在调用内部类的方法时才会初始化内部类。
是性能最优的且线程安全的一种懒汉式单例写法

class LazyInnerClassSingleton{ private LazyInnerClassSingleton(){} public static final LazyInnerClassSingleton getInstance() { return LazyHoder.instance; } //延迟加载 private static class LazyHoder{ private static final LazyInnerClassSingleton instance=new LazyInnerClassSingleton(); } } 

反射破坏单例

但是，上面这种方法就是完美的么？我们先来看一个测试例子

class LazyInnerClassSingletonTest{ public static void main(String[] args) { try {             Class<?>clazz=LazyInnerClassSingleton.class;             Constructor c=clazz.getDeclaredConstructor(null);              c.setAccessible(true);//强吻              Object o1=c.newInstance();              Object o2=LazyInnerClassSingleton.getInstance();             System.out.println(o1==o2); } catch (Exception e) {             e.printStackTrace(); } } } 

运行结果：

可以看到，我们通过反射来调用其构造方法，和调用getInstance方法，出现了两个不同的实例，这种情况怎么解决呢？

class LazyInnerClassSingleton{ private LazyInnerClassSingleton(){ if(LazyHoder.instance!=null){ throw new RuntimeException("不允许创建多个实例"); } } public static final LazyInnerClassSingleton getInstance() { return LazyHoder.instance; } //延迟加载 private static class LazyHoder{ private static final LazyInnerClassSingleton instance=new LazyInnerClassSingleton(); } } 

我们通过构造方法的判断和异常，让调用者只能通过getInstance去拿实例

序列化破坏单例

一个对象创建完成，有时需要将对象序列化后写入磁盘，下次使用再从磁盘读取对象并进行反序列化，将其转成内存对象。反序列化后的对象会重新分配内存，即重新创建。如果序列化的对象是单例对象，就会破坏单例

public class HungerSingleton implements Serializable{ private static final HungerSingleton instance =new HungerSingleton(); private HungerSingleton(){} public static HungerSingleton getInstance(){ return instance; } public static HungerSingleton deepClone(HungerSingleton hs){         HungerSingleton i =null; try { //序列化对象             FileOutputStream fo=new FileOutputStream("HungerSingleton.obj");             ObjectOutputStream os=new ObjectOutputStream(fo);             os.writeObject(hs);              os.flush();             os.close(); //反序列化对象             FileInputStream fi=new FileInputStream("HungerSingleton.obj");             ObjectInputStream ois=new ObjectInputStream(fi);             i=(HungerSingleton)ois.readObject();             ois.close(); } catch (Exception e) {             e.printStackTrace(); } return i; } public static void main(String[] args) {         HungerSingleton i=HungerSingleton.getInstance();         HungerSingleton ii=deepClone(i);         System.out.println(i==ii); } } 

运行结果：

很明显，序列化后的对象和手动创建的对象是不一致的，实例化了两次。那么，怎么去解决这个问题呢？很简单，只需要增加readResolve方法就可以了

public class HungerSingleton implements Serializable{ private static final HungerSingleton instance =new HungerSingleton(); private HungerSingleton(){} public static HungerSingleton getInstance(){ return instance; } //序列化破坏单例的解决方案： //重写readResolve方法 private Object readResolve(){ return instance; } } 

再来看结果：

注册式单例

注册式单例又被称为登记式单例，就是讲每一个实例都登记到某一个地方，使用唯一标识获取单例

枚举式单例

enum EnumSingleton{     INSTANCE; private Object obj; private Object getObj(){ return obj; } public static EnumSingleton getInstance(){ return INSTANCE; } public static void main(String[] args) {         EnumSingleton e1=EnumSingleton.getInstance();         EnumSingleton e2=EnumSingleton.getInstance();         System.out.println(e1==e2); } } 

枚举法单例模式是《Effective Java》书中推荐的一种单例模式实现写法

缺点

• 在类加载之时就将所有的对象初始化放在内存中，与饿汉式一样，不适合大量创建单例对象的场景

ThreadLocal单例

前面我们也讲过ThreadLocal，它是单个线程唯一的，天生就是线程安全的

class ThreadLocalSingleton{ private ThreadLocalSingleton(){} private static final ThreadLocal<ThreadLocalSingleton> instance=new ThreadLocal<ThreadLocalSingleton>(){ @Override protected ThreadLocalSingleton initialValue() { return new ThreadLocalSingleton(); } }; private static ThreadLocalSingleton getInstance(){ return instance.get(); } } 

ThreadLocal单例也算是一种特殊的单例模式吧，对ThreadLocal原理感兴趣的可以去看之前的文章深入理解ThreadLocal

总结

一般建议使用饿汉式单例。只有在要明确实现 lazy loading 效果时，才会使用内部类实现的单例模式。如果涉及到反序列化创建对象时，可以尝试使用第枚举方式。如果有其他特殊的需求，可以考虑使用双重检锁方式。