设计模式之单例模式

概述：在一个系统中对于某个类只能存在一个对象实例，并且提供获取对象实例的静态方法。

使用场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或耗费资源过多（即：重量级对象）、但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（如数据源、session工厂等）。

分类：

1. 饿汉模式（静态常量）
2. 饿汉模式（静态代码块）
3. 懒汉模式（线程不安全）
4. 懒汉模式（线程安全，同步方法）
5. 懒汉模式（线程安全，同步代码块）
6. 双重检查
7. 静态内部类
8. 枚举

饿汉模式（静态常量）

 代码演示：

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

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

 优缺点：

     优点：写法比较简单，在类加载的时候完成实例化，避免了线程同步问题

     缺点：在类加载的时候完成实例化，没有达到懒加载的效果。如果从没有使用过这个实例将造成内存的浪费

饿汉模式（静态代码块）

代码演示

class Singleton{
    
      private Singleton(){}
     
      private static Singleton singleton；
   
      static{

           singleton=new Singleton();

      }

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

优缺点和静态常量的模式是一样的。

懒汉模式（线程不安全）

代码演示

class Singleton{
    
      private Singleton(){}
     
      private final static Singleton singleton;

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

优缺点

  优点：懒加载，单线程下使用

  缺点：单线程下使用，若果在多线程下，一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以只能在单线程下使用。在实际开发中，不能使用这种模式。

懒汉模式（线程安全，同步方法）

代码演示

class Singleton{
    
      private Singleton(){}
     
      private static Singleton singleton;

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

优缺点

1.  解决了线程不安全的问题
2. 效率低下，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步，而其实这个方法只执行实例化代码够了，后面的想获得该实例，直接return就行了，方法进行同步效率太低。所以在实际开发中不推荐使用这种方式。

懒汉模式（线程安全，同步代码块）

代码演示

class Singleton{
    
      private Singleton(){}
     
      private static Singleton singleton;

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

优缺点

不能起到线程同步的作用，在多线程的环境下也会产生多个实例，在实际开发中不能使用这种方法。

双重检查模式

代码演示

class Singleton{
    
      private Singleton(){}
     
      private static volatile Singleton singleton;

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

优缺点

1. 在多线程中使用到，进行了两次判断检查，保证了线程安全
2. 实例化代码只执行一次，后面再次访问时，直接获取实例化对象，也避免反复进行方法同步
3. 线程安全，延迟加载，效率较高
4. 所以在实际开发中，推荐使用这种模式。

静态内部类

代码演示

class Singleton {
	private Singleton(){}

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

优缺点

1. 采用了类装载的机制来保证初始化实例时只有一个线程
2. 静态内部类并不是随类加载而加载，而是在需要实例化时，才会装载进而完成实例化
3. 类的静态属性只会在第一次加载类的时候初始化，是jvm保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
4. 避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高。在实际开发中推荐使用。

枚举模式

代码演示

enum Singleton{
	INSTANCE;
}

优缺点

1. 借助jdk中的枚举来实现单列模式。不仅能避免多线程同步的问题，而且还能反正反序列化重新创建的对象
2. 代码简单高效，推荐使用。

补充：

1. jdk源码中的java.lang.Runtime()是经典的单列模式（饿汉）
2. 单例模式保证了系统内存中只存在一个对象，节省了系统资源，对于一些需要频繁创建与销毁的对象，使用单例模式可以提供系统性能
3. 当想实例化一个单例类的时候，必须要使用相应的获取对象的方法，而不是使用new