设计模式-单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

单例模式的应用场景：

1.在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。

2.当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

3.当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

实现：

1.懒汉式，线程不安全

/**
 * 
 * @ClassName: Singleton
 * @Description: 懒汉式单例（在第一次调用的时候实例化自己）
 * 这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
 * @author: ljx
 * @date: 2018年12月25日 下午3:15:34
 */
public class Singleton {
    //构造函数私有化
    private Singleton(){}
    
    private static Singleton singleton = null;
    
    //构建实例化方法
    public static Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

2.懒汉式，线程安全

/**
 * 
 * @ClassName: Singleton
 * @Description: 懒汉式单例（在第一次调用的时候实例化自己）
 * 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
 * 优点：第一次调用才初始化，避免内存浪费。
 * 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
 * @author: ljx
 * @date: 2018年12月25日 下午3:15:34
 */
public class Singleton {
    //构造函数私有化
    private Singleton(){}
    
    private static Singleton singleton = null;
    
    //构建实例化方法
    public static synchronized Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

3.饿汉式

/**
 * 
 * @ClassName: Singleton2
 * @Description: 饿汉式
 * 这种方式比较常用，但容易产生垃圾对象。
 * 优点：没有加锁，执行效率会提高。
 * 缺点：类加载时就初始化，浪费内存。
 * @author: ljx
 * @date: 2018年12月25日 下午3:30:39
 */
class Singleton2 {
        //私有构造函数
    private Singleton2(){};
    private static Singleton2 singleton2= new Singleton2();
    public static Singleton2 getSingleton2(){
        return singleton2;
    }
}

4.双检锁/双重校验锁

/**
 * 
 * @ClassName: Singleton3
 * @Description: 双检锁/双重校验锁（DCL，即 double-checked locking）
 * 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
 * @author: ljx
 * @date: 2018年12月25日 下午3:44:16
 */
class Singleton3{
    //私有构造函数
    private Singleton3(){}
    
    private static Singleton3 singleton3 = null;
    
    public static Singleton3 getSingleton3(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(singleton3 == null){
            //同步块，线程安全的创建实例
            synchronized (Singleton3.class) {
                //再次检查实例是否存在，如果不存在才真正的创建实例
                if(singleton3 == null){
                    singleton3 = new Singleton3();
                }
            }
        }
        return singleton3;
    }
    
}

5.静态(类级)内部类

/**
 * 
 * @ClassName: Singleton4
 * @Description: 静态(类级)内部类：这种方式能达到双检锁方式一样的功效，但实现更简单。
 * 对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。
 * 这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
 * @author: ljx
 * @date: 2018年12月25日 下午4:05:11
 */
class Singleton4{
    private Singleton4(){};
    
    /**
     * 
     * @ClassName: Singleton4Holder
     * @Description: 类级内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
         * 没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     * @author: ljx
     * @date: 2018年12月25日 下午4:04:03
     */
    private static class Singleton4Holder{
        //静态初始化器，由JVM来保证线程安全
        private static Singleton4 singleton4 = new Singleton4();
    }
    
    public static Singleton4 getSingleton4(){
        return Singleton4Holder.singleton4;
    }
}

6.单例和枚举

/**
 * 
 * @ClassName: Singleton5
 * @Description: 枚举单例模式
 * @author: ljx
 * @date: 2018年12月25日 下午4:16:09
 */
enum Singleton5{
    SINGLETON5;
}

是不是非常简单，非常简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

enum有且仅有private的构造器，防止外部的额外构造，这恰好和单例模式吻合，也为保证单例性做了一个铺垫。

想要了解enum是如何工作的，就要对其进行反编译。

反编译后就会发现，使用枚举其实和使用静态类内部加载方法原理类似。枚举会被编译成如下形式：

public final class Singleton5 extends Enum{
    //私有构造方法，这里调用了父类的构造方法，其中参数s对应了常量名，参数i代表枚举的一个顺序(这个顺                       序与枚举的声明顺序对应，用于oridinal()方法返回顺序值)
    private Singleton5()
    {
        super();
    }
    //定义的枚举在这里声明了SINGLETON5 Singleton5的常量对象引用
    public static final Singleton5 $VALUES;
 
    //将所有枚举的实例存放在数组中
    private static final Singleton5 $VALUES[];
    
    //对象的实例化在static静态块中
    static 
    {
        SINGLETON5 = new Singleton5("SINGLETON5", 0);
        //将所有枚举的实例存放在数组中
        $VALUES = (new Singleton5[] {
            SINGLETON5
        });
    }
}

其中，Enum是Java提供给编译器的一个用于继承的类。枚举量的实现其实是public static final T 类型的未初始化变量，之后，会在静态代码中对枚举量进行初始化。所以，如果用枚举去实现一个单例，这样的加载时间其实有点类似于饿汉模式，并没有起到lazy-loading的作用。

对于序列化和反序列化，因为每一个枚举类型和枚举变量在JVM中都是唯一的，即Java在序列化和反序列化枚举时做了特殊的规定，枚举的writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法是被编译器禁用的，因此也不存在实现序列化接口后调用readObject会破坏单例的问题。

测试：

/**
 * 
 * @ClassName: Singleton5
 * @Description: 枚举单例模式
 * @author: ljx
 * @date: 2018年12月25日 下午4:16:09
 */
enum Singleton5{
    SINGLETON5;//定义枚举类型
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class Test{
    public static void main(String[] args) {
        Singleton5 singleton1 = Singleton5.SINGLETON5;//枚举类型实例化（静态块中）
        singleton1.setName("单例1");
        System.out.println(singleton1.getName());
        
        Singleton5 singleton2 = Singleton5.SINGLETON5;
        singleton2.setName("单例2");
        System.out.println(singleton2.getName());
        
        System.out.println(singleton1.getName() + ":" + singleton2.getName());
        
    }
}

结果：

单例1

单例2

单例2:单例2