保证系统内存只有一个对象，节省系统资源，对于需要频繁创建销毁的对象，使用单例模式可以提高性能

提供一个获取对象的方法，而不是直接new

单例模式主要分为两大类

  • 饿汉模式：类装载的时候就创建对象
  • 懒汉模式：需要用到对象的时候创建

使用单例模式，首先是要私有化构造器

单例模式各种线程安全和不安全的写法加起来一共有八种写法

防止反射调用

可在私有化的无参构造方法里加一段，调用无参构造直接抛异常

  1.         if(instance != null){
  2.             throw new RuntimeException("单例模式禁止反射调用");
  3.         }

饿汉模式写法

通常使用静态static关键字

  1. public class StaticSingletonTest {
  3.     private final static StaticSingletonTest instance = new StaticSingletonTest();
  5.     private StaticSingletonTest() {
  6.         if(instance != null){
  7.             throw new RuntimeException("单例模式禁止反射调用");
  8.         }
  9.     }
  11.     public static StaticSingletonTest getInstance() {
  12.         return instance;
  13.     }
  15. }

也可以使用静态代码块来写

注意：静态代码块是按照顺序执行的！！！

  1. private final static StaticSingletonTest instance;
  3. static {
  4.     instance = new StaticSingletonTest();
  5. }
  7. public static StaticSingletonTest getInstance() {
  8.     return instance;
  9. }

两种写法没有本质区别

懒汉模式写法

在需要使用该对象的时候再实例化对象

双重判断同步写法

为了线程安全需要使用synchronized关键字和volatile关键字

这里必须加volalite的原因：

new 对象的过程分为三步：

1.分配空间

2.初始化对象

3.指向对象内存地址。

2和3可能被编译器自动重排，导致判断非空但是实际拿的对象还未完成初始化

  1. public class LazySingleton {
  3.     //加volatile关键字避免指令重排
  4.     private volatile static LazySingleton instance;
  6.     //解决高并发时创建多个对象 最简单的方法就是在方法上加个synchronized,然后方法里只需要做一次判断
  7.     //但是这是静态方法锁的就是这个class了,性能受影响,取而代之的是双重判断+同步代码块
  8.     //这里只需要锁判断对象是否创建就行了
  9.     public static /*synchronized*/ LazySingleton getInstance() {
  10.         if (instance == null) {
  11.             //优化的方法,使用同步代码块
  12.             synchronized (LazySingleton.class) {
  13.                 //在多线程情况下需要判断，避免多实例
  14.                 if (instance == null) {
  15.                     instance = new LazySingleton();
  16. //                    1.分配空间 ->返回一个指向该空间的一个内存引用
  17. //                    2.对空间进行初始化
  18. //                    3.把内存引用复制给 变量
  19. //                    但是运行过程中2和3的顺序可能不对,出现指令重排,所以需要volatile关键字定义
  21.                 }
  22.             }
  23.         }
  24.         return instance;
  25.     }
  27.     private LazySingleton() {}
  29. }

有线程不安全懒汉式，线程安全懒汉式，同步代码块懒汉式，双重判断懒汉式

这里列举的是双重判断懒汉式

静态内部类写法

  1. public class InnerSingleton {
  3.     //外部类在装载的时候静态内部类是不会被装载的
  4.     private static class Inner {
  5.         private final static InnerSingleton instance = new InnerSingleton();
  6.     }
  8.     //在此方法调用的时候才装载内部类，而且内部类只装载一次,线程安全
  9.     public static InnerSingleton getInstance() {
  10.         //调用此属性才会触发内部类的加载
  11.         return Inner.instance;
  12.     }
  14.     private InnerSingleton() {}
  15. }

枚举类的写法

  1. public class EnumForSingleton {
  2.     private EnumForSingleton() {}
  4.     public EnumForSingleton getInstance() {
  5.         return Singleton.INSTANCE.getInstance();
  6.     }
  8.     private enum Singleton {
  9.         /**
  10.          * 只写一个属性即可
  11.          * 用来获取单实例对象
  12.          * 这个枚举类本身也是单例的
  13.          */
  14.         INSTANCE;
  16.         private EnumForSingleton singleton;
  18.         /**
  19.          * 枚举构造函数创建实例
  20.          * JVM这个方法只会调用一次
  21.          * 实例调用的时候才初始化
  22.          * 属于懒汉模式
  23.          */
  24.         Singleton() {
  25.             singleton = new EnumForSingleton();
  26.         }
  28.         public EnumForSingleton getInstance() {
  29.             return singleton;
  30.         }
  31.     }
  32. }

单例模式写法虽然有八种，但是能用的只有四种(饿汉的两种写法算一种)