设计模式-单例模式

介绍，适用场景

在Java开发过程中，有时候需要保证一个类仅有一个实例，并提供一个访问它的全局访问点。比如在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这一类对象只能有一个实例，如果制造出多个实例就可能会导致一些问题的产生。

优点

• 对于频繁使用的对象，可以省略创建对象所花费的时间
• 由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

实现

通常要满足以下几点：

• 必须要有一个 private 访问级别的构造函数，这样才能确保单例不会在外部被实例化（事实上，通过Java反射机制是能够实例化构造方法为private的类的，此问题在此处不做讨论。）
• 成员变量和方法是 static 的

几种实现方式：

• 饿汉方式(线程安全）
• 懒汉式（非线程安全)
• 懒汉式 (线程安全和双重检查加锁版本)
• 懒汉式（静态内部类方式）
• 饿汉式（枚举方式）

饿汉方式(线程安全）

    public class Singleton {
       //在静态初始化器中创建单例实例，这段代码保证了线程安全
        private static Singleton single = new Singleton();
        
        private Singleton(){}
        public static Singleton getInstance(){
            return single;
        }
    }

不管你用不用，先创建了再说，如果一直没有被使用，便浪费了空间

懒汉式（非线程安全)

public class Singleton {  
      private static Singleton single;  
      private Singleton (){
      }   
      
      public static Singleton getInstance() {
          //判断当前单例是否已经存在，若存在则返回，不存在则再建立单例
	      if (single == null) {  
	          single = new Singleton();  
	      }  
	      return single;  
      }  
 }

上面这种方式很明显是线程不安全的，如果多个线程同时访问getInstance()方法时就会出现问题。

懒汉式 (线程安全和双重检查加锁版本)

public class Singleton {
    private static Singleton single = null;
    private Singleton() {
    }

    public static Singleton getInstance() {
        // 等同于 synchronized public static Singleton getInstance()
        synchronized(Singleton.class){
          // 避免出现线程安全问题
            if(single == null){
                single = new Singleton();
            }
        }
        return single;
    }
}

在方法上加synchronized同步锁，虽然解决了多个实例对象问题，但是该方式运行效率却很低下，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，才可以继续运行。

双重加锁

public class Singleton {

    //volatile保证多个线程可以正确处理single变量
    private volatile static Singleton single;
    private Singleton() {
    }
    public static Singleton getInstance() {
       //检查实例，如果不存在，就进入同步代码块
        if (single == null) {
            
            synchronized(Singleton.class) {
               //进入同步代码块后，再检查一次，如果仍是null，才创建实例
                if (single == null) {
                    single = new Singleton();
                }
            }
        }
        return single;
    }
}

这种方式相比于使用synchronized关键字的方法，可以大大减少getInstance() 的时间消费。

懒汉式（静态内部类方式）

public class Singleton {  
    private static class SingletonInner {  
      private static final Singleton single = new Singleton();  
    }  
    private Singleton (){
    }  
    public static final Singleton getInstance() {  
      return SingletonInner.single;  
    }  
}   

静态内部类保证了线程的安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的。

饿汉式（枚举方式）

public enum Singleton {
	 //定义一个枚举的元素，它就是 Singleton 的一个实例
    SINGLE;  
}

使用方法

public class Test {
	public static void main(String[] args) {
		Singleton singleton = Singleton.SINGLE;
	}
}

它更简洁，自动支持序列化机制，绝对防止多次实例化