单例模式
主要作用：为系统生成唯一的一个实例（对象），永久驻留在内存中，减少了系统的资源开销。
常用的实现方式：
1、饿汉式
优点：线程安全、调用效率高
缺点：不能延时加载
代码：
public class SingletonDemo01 { //类初始化时，立即加载这个对象（无延时加载优势），加载类时是天然线程安全的 private static SingletonDemo01 instance = new SingletonDemo01(); //私有构造方法 private SingletonDemo01() {} //加载类时是天然线程安全的，不需要同步，调用效率高 public static SingletonDemo01 getInstance() { return instance; } }
2、懒汉式
优点：线程安全、可延时加载
缺点：调用效率不高（每次调用都得同步，并发效率低）
代码：
public class SingletonDemo02 { //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建） private static SingletonDemo02 instance; //私有化构造器 private SingletonDemo02(){ } //获取实例方法，synchronized进行同步，调用效率低 public static synchronized SingletonDemo02 getInstance() { if (instance == null) { instance = new SingletonDemo02(); } return instance; } }
3、静态内部类式
优点：线程安全、调用效率高、可延时加载，兼具了饿汉式和懒汉式的优点。
缺点：
代码：
public class SingletonDemo03 { //静态内部类，，只有调用getInstance方法时才会进行加载（延时加载） private static class InnerClass { //static final修饰instance，保证实例在内存中唯一（线程安全） private static final SingletonDemo03 instance = new SingletonDemo03(); } //私有构造器 private SingletonDemo03() { } //获取实例方法 public static SingletonDemo03 getInstance() { return InnerClass.instance; } }
4、枚举式
优点：基于JVM底层实现，天然单例，线程安全、调用效率高
缺点：不能延时加载
代码：
public enum SingletonDemo04 { //该枚举元素本身就是单例的 INSTANCE; }
代码测试
public class Main { public static void main(String[] args) { //饿汉式创建的对象都是同一个对象 SingletonDemo01 instance1 = SingletonDemo01.getInstance(); SingletonDemo01 instance2 = SingletonDemo01.getInstance(); System.out.println("饿汉式创建的2个实例是同一个对象？" + (instance1 == instance2)); //懒汉式创建的对象都是同一个对象 SingletonDemo02 instance3 = SingletonDemo02.getInstance(); SingletonDemo02 instance4 = SingletonDemo02.getInstance(); System.out.println("懒汉式创建的2个实例是同一个对象？" + (instance3 == instance4)); //静态内部类创建的对象都是同一个对象 SingletonDemo03 instance5 = SingletonDemo03.getInstance(); SingletonDemo03 instance6 = SingletonDemo03.getInstance(); System.out.println("静态内部类方式创建的2个实例是同一个对象？"+ (instance5 == instance6)); //枚举式创建的对象都是同一个对象 SingletonDemo04 instance7 = SingletonDemo04.INSTANCE; SingletonDemo04 instance8 = SingletonDemo04.INSTANCE; System.out.println("枚举式创建的2个实例是同一个对象？"+ (instance7 == instance8)); } }
输出结果：
饿汉式创建的2个实例是同一个对象？true 懒汉式创建的2个实例是同一个对象？true 静态内部类方式创建的2个实例是同一个对象？true 枚举式创建的2个实例是同一个对象？true
总结
当实例化对象非常占用系统资源且需要延时加载时，推荐使用懒汉式、静态内部类式（优于懒汉式）；
当实例化对象占用系统资源小时且要立即加载时，推荐使用饿汉式、枚举式（优于饿汉式）。
扩展
单例模式中的枚举式基于JVM底层实现，是天然线程安全的，但是其他创建单例的方法用反射和反序列化的手段是可以破解的（可以创建多个不同的对象）。
这里以饿汉式为例：
未特殊处理的饿汉式代码：
public class SingletonDemo05 implements Serializable{ //类初始化时，立即加载这个对象（无延时加载优势），加载类时是天然线程安全的 private static SingletonDemo05 instance = new SingletonDemo05(); //私有构造方法 private SingletonDemo05() {} //加载类时是天然线程安全的，不需要同步，调用效率高 public static SingletonDemo05 getInstance() { return instance; } }
反射、反序列破解代码：
public class Main2 { public static void main(String[] args) throws Exception{ SingletonDemo05 s1 = SingletonDemo05.getInstance(); SingletonDemo05 s2 = SingletonDemo05.getInstance(); System.out.println("饿汉式创建的2个实例是同一个对象？" + (s1 == s2)); //反射方式破解单例 Class<SingletonDemo05> clazz = (Class<SingletonDemo05>) Class.forName("com.led.singleton.SingletonDemo05"); Constructor<SingletonDemo05> constructor = clazz.getDeclaredConstructor(null); //使用下面的方法才能访问私有方法 constructor.setAccessible(true); SingletonDemo05 s3 = constructor.newInstance(); System.out.println("反射生成的对象和正常生成的是同一个对象吗？" + (s1 == s3));//false //反序列化方式破解单例 //1、先序列化到本地磁盘（SingletonDemo05需要实现Serializable接口） FileOutputStream fos = new FileOutputStream("D:/a.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); //Write the specified object to the ObjectOutputStream oos.writeObject(s1); if (oos != null) { oos.close(); } if (fos != null) { fos.close(); } //2、从磁盘反序列化到内存 FileInputStream fis = new FileInputStream("D:/a.txt"); ObjectInputStream ois = new ObjectInputStream(fis); SingletonDemo05 s4 = (SingletonDemo05) ois.readObject(); if (ois != null) { ois.close(); } if (fis != null) { fis.close(); } System.out.println("正常创建的和反序列化生成的是同一个对象？" + (s1 == s4));//false } }
控制台输出：
饿汉式创建的2个实例是同一个对象？true 反射生成的对象和非反射生成的是同一个对象吗？false 正常创建的和反序列化生成的是同一个对象？false
由此可见，不对饿汉式代码进行特殊处理，使用反射和反序列方法会破坏单例性。
对反射的特殊处理：
对饿汉式类中的构造方法进行修改，当已经有实例时，抛出异常，防止创建多个不同实例
//私有构造方法 private SingletonDemo05() { if (instance != null) { throw new RuntimeException("实例已存在"); } }
控制台输出：
饿汉式创建的2个实例是同一个对象？true Exception in thread "main" java.lang.reflect.InvocationTargetException at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:423) at com.led.singleton.Main2.main(Main2.java:25) Caused by: java.lang.RuntimeException: 实例已存在 at com.led.singleton.SingletonDemo05.<init>(SingletonDemo05.java:18) ... 5 more
对反序列化的特殊处理：
在饿汉式类中通过定义readResolve()防止获得不同对象
//通过定义readResolve()防止获得不同对象 private Object readResolve() throws ObjectStreamException { return instance; }
控制台输出：
正常创建的和反序列化生成的是同一个对象？true
特殊处理的饿汉式代码：
public class SingletonDemo05 implements Serializable{ //类初始化时，立即加载这个对象（无延时加载优势），加载类时是天然线程安全的 private static SingletonDemo05 instance = new SingletonDemo05(); //私有构造方法 private SingletonDemo05() { //通过抛出异常，防止反射通过构造器创建多个实例 if (instance != null) { throw new RuntimeException("实例已存在"); } } //加载类时是天然线程安全的，不需要同步，调用效率高 public static SingletonDemo05 getInstance() { return instance; } //通过定义readResolve()方法，防止通过反序列化方式创建多个实例 private Object readResolve() throws ObjectStreamException { return instance; } }
