设计模式个人理解-单例模式（三）

简介

• 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。就是一个类只有一个对象实例。

使用场景

• 需要频繁创建的一些类，使用单例可以降低系统的内存压力；
• 某些类创建实例时占用资源较多，或者实例化耗时较长，还经常使用经常使用；
• 频繁访问数据库或文件的对象；
• 对于一些控制硬件级别的操作或者从系统上来讲应当是单一的控制逻辑的操作，如果有多个实例的话，系统就会完全乱套；

写法

懒汉式

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

• 懒汉式，又叫懒加载，只有明确调用getInstance()时才会实例化对象，这样就达到了懒加载的目的。

饿汉式

public class EHan{
    private static final EHan ehan= new EHan();
    private EHan() {
    }
    public static EHan getInstance() {
        return ehan;
    }
}

• 饿汉式，就是立刻加载。也就是说在类加载的时候，就立即实例化对象。上面这种单例写法在类被装载的时候，ehan就会被创建，没有延迟加载的效果。

双检锁

public class DoubleLock implements Serializable{
    public static volatile DoubleLock doubleLock = null;
    private DoubleLock(){
    }

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

• 也叫双重校验锁，是一种使用同步块加锁的方法。因为会有两次检查 ，一次是在同步块外，一次是在同步块内。因为有可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

静态内部类

public class JT{
    private JT() {
    }
    private static class SingletonHolder {
        private static final JT jt= new JT();
    }
    public static final JT getInstance() {
        return SingletonHolder.jt;
    }
}

• 使用静态内部类写法，单例模式会有延迟加载特性，因为JT 加载并不会导致SingletonHolder被加载，所以并未发生new JT 过程，一般只有在显示调用JT .getInstance()时，JT 才会被加载，同时导致JT 被创建。

枚举

//我们实际需要单例的类
public class MeiJu{
    private MeiJu(){
    }

    private enum EnumSingleton {
        INSTANCE;
        private final MeiJu meiju ;
    
        EnumSingleton() {
            meiju = new MeiJu();
        }
    }
    public static MeiJu getInstance() {
        return EnumSingleton.INSTANCE.singleton;
    } 
}