单例模式

一.作用：
保证全局对象唯一，以此保证对象的状态一致，相关配置参数一致

---

二.特点：
1）构造器私有化
2）只能自己给自己创建唯一实例
3）必须给其它对象提供获取该对象的公共方法

---

三.写法

• 1. 饿汉式–静态变量–立即加载–线程安全

public class Singleton {

   private final static Singleton INSTANCE = new Singleton();

   private Singleton(){}

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

• 优点：
  类加载完就完成对象实例化，线程安全
• 缺点：
  即使对象未使用，也会占用一定的内存

• 2. 饿汉式-静态代码块–立即加载–线程安全

public class Singleton {

   private static Singleton instance;

   static {
       instance = new Singleton();
   }

   private Singleton() {}

   public static Singleton getInstance() {
       return instance;
   }
}
}

• 优点：
  同静态变量，类加载完就完成对象实例化，线程安全
• 缺点：
  同静态变量，即使对象未使用，也会占用一定的内存

• 3. 懒汉式–静态方法–延迟加载–线程不安全

public class Singleton {

   private static Singleton singleton;

   private Singleton() {}

   public static Singleton getInstance() {
       if (singleton == null) {
           singleton = new Singleton();
       }
       return singleton;
   }
}

• 优点：
  延迟加载
• 缺点：
  有线程安全问题

• 4. 懒汉式–静态同步方法(类锁)–延迟加载–线程安全

public class Singleton {

   private static Singleton singleton;

   private Singleton() {}

   #静态同步方法
   public static synchronized Singleton getInstance() {
       if (singleton == null) {
           singleton = new Singleton();
       }
       return singleton;
   }
}

• 优点：
  延迟加载、线程安全
• 缺点：
  每次获取对象前，必须先获取锁(必须等待其它线程将锁释放)，即使对象已经创建了，效率低

• 5. 懒汉式–静态同步代码块(锁外无if判断)–延迟加载–线程安全

public class Singleton {

   private static Singleton singleton;

   private Singleton() {}

   #静态同步代码块
   public static Singleton getInstance() {
   	synchronized (Singleton.class){
   		if (singleton == null) {
           	singleton = new Singleton();
       	}
   	}
       return singleton;
   }
}

• 优点：
  同静态同步方法，延迟加载、线程安全
• 缺点：
  同静态同步方法，每次获取对象前，必须先获取锁(必须等待其它线程将锁释放)，即使对象已经创建了，效率低

• 6. 懒汉式–静态同步代码块(判断一次加同步锁)–延迟加载–线程不安全

public class Singleton {

   private static Singleton singleton;

   private Singleton() {}

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

• 优点：
  延迟加载，加锁前先判断是否需要加锁，比第5种方法的效率要高
• 缺点：
  线程不安全，当同时有线程1、2执行了if ()判断条件成立，此时线程1获取到了锁，线程2等待，当线程1执行完之后，对象已经创建了，但线程2会继复创建对象，造成多个对象实例和单例相违背，所以线程不安全

• 7. 懒汉式–静态同步代码块(双重检查判断)–延迟加载–线程安全

public class Singleton {

   private static volatile Singleton singleton;

   private Singleton() {}

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

• 优点：
  延迟加载，线程安全，双重判读，在加锁前后都判断，
• 缺点：
  无

• 懒汉式–静态内部类–延迟加载–线程安全

public class Singleton {

   private Singleton() {}

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

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

• 优点：
  延迟加载，线程安全，
  同方法1，都是采用类的记载机制保证初始化时，只有一个线程，
  但不同的是，方法1是Singleton在加载时就初始化创建了对象，本方法中是在调用getInstance()方法时，加载内部类SingletonInstance，实例化内部类的静态变量获取实例对象（静态变量在加载时被初始化，只会被初始化一次，由jvm保证线程安全）
• 缺点：
  无