设计模式-单例模式

单例模式简介

    单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。

饿汉式(静态常量)

/**
 * 单例模式：饿汉式(静态常量)
 * 优点：写法简单，类装载时候就完成了实例化，避免了多线程同步问题
 * 缺点：在类装载时候就完成了实例化，没有达到Lazy Loading的效果，如果从始至终未使用过这个实例，则会造成内存的浪费。
 */
class Singleton {
    /**
     * 构造器私有化，避免外部new这个类
     */
    private Singleton() {

    }
    /**
     * 类内部创建对象实例
     */
    private final static Singleton instance = new Singleton();

    /**
     * 提供一个公有的静态方法，返回实例对象
     * @return
     */
    public static Singleton getSingleton() {
        // 编写相关实现方法
        return instance;
    }
}

饿汉式(静态代码块)

与静态常量优缺点相同。

/**
 * 单例模式：饿汉式(静态代码块)
 * 优点：写法简单，类装载时候就完成了实例化，避免了多线程同步问题
 * 缺点：在类装载时候就完成了实例化，没有达到Lazy Loading的效果，如果从始至终未使用过这个实例，则会造成内存的浪费。
 */
class Singleton {
    /**
     * 构造器私有化，避免外部new这个类
     */
    private Singleton() {

    }
    /**
     * 类内部定义对象实例
     */
    private final static Singleton instance;

    static {
        // 在静态代码块中创建对象实例
        instance = new Singleton();
    }

    /**
     * 提供一个公有的静态方法，返回实例对象
     * @return
     */
    public static Singleton getSingleton() {
        return instance;
    }
}

懒汉式(线程不安全)

/**
 * 懒汉式(与饿汉式不同，非常量，多线程存在创建多个实例情况---线程不安全)
 * 优点：起到了Lazy Loading效果
 * 缺点：只适用于单线程下使用，如果多线程下，一个线程进入if判断块，还未来得及往下执行，
 * 另外一个线程也通过了这个判断语句，这时就会多产生多个实例。---线程不安全
 */
class Singleton {
    /**
     * 类内部定义对象实例
     */
    private static Singleton instance;


    /**
     * 提供一个公有的静态方法
     * 当使用到这个方法时，才创建实例
     * 即懒汉式
     * @return
     */
    public static Singleton getSingleton() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉式(线程安全)

/**
 * 懒汉式(线程安全,同步方法)
 * 优点：起到了Lazy Loading效果，解决了线程不安全问题
 * 缺点：效率太低了，每个线程在想要获得类的实例时候，执行getSingleton()都要进行同步。
 * 而其实这个方法只执行一次实例化就够了，后面想要获得该类实例，直接return就行了，
 * 方法进行同步效率太低
 */
class Singleton {
    /**
     * 类内部定义对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，加入了同步处理方法synchronized，
     * 当getSingleton方法在执行时，其他想要使用此方法的操作进行排队，避免了创建多个实例
     * @return
     */
    public static synchronized Singleton getSingleton() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查式(推荐使用)

/**
 * 懒汉式(双重检查：线程安全,同步方法)
 * 优点：Double-Check概念是多线程开发中常使用的，实例化代码只用执行一次，后面再次访问时，判断if(instence == null)，
 * 直接return返回实例化对象，避免了反复进行方法同步；线程安全，延迟加载，效率较高。
 * 实际开发中，推荐使用这种单例设计模式
 */
class Singleton {
    /**
     * 类内部定义对象实例
     * volatile 作用
     * 1. 可见性
     * 可见性是指多个线程访问同一个变量时，其中一个线程修改了该变量的值，其它线程能够立即看到修改的值。
     * 2. 原子性
     * volatile 只保证单次读/写操作的原子性，对于多步操作，volatile 不能保证原子性
     * 有序性
     * 在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，但是会影响到多线程并发执行的正确性。
     */
    private static volatile Singleton instance;


    /**
     * 提供一个公有的静态方法，加入了同步处理方法，
     * @return
     */
    public static synchronized Singleton getSingleton() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类式(推荐使用)

/**
 * 静态内部类(推荐使用)
 * 优点：
 * 采用了类装载的机制来保证初始化实例时只有一个线程
 * 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用genInstance方法，
 * 才会装载SingletonInstance类，从而完成Singleton的实例化。
 * 类的静态属性只会在第一次加载类的时候初始化，JVM的类加载帮助保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
 * 避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
 */
class Singleton {

    /**
     * 定义静态内部类
     * 该类在Singleton类加载时，不会被加载，只有调用getSingleton()方法时，才会被加载
     * 且在加载过程中借用了JVM类加载机制，保证了线程安全。
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }


    /**
     * 提供一个公有的静态方法，加入了同步处理方法，
     * @return
     */
    public static synchronized Singleton getSingleton() {
        return SingletonInstance.INSTANCE;
    }
}

以上实现单例模式的调用方法相同，如下：

public static void main(String[] args) {
        Singleton singleton = Singleton.getSingleton();
        Singleton singleton1 = Singleton.getSingleton();
        System.out.println(singleton == singleton1);    // 输出ture
        System.out.println("singleton的hashCode：" + singleton.hashCode());  //hashCode值与下面值相同
        System.out.println("singleton1的hashCode：" + singleton1.hashCode()); //hashCode值与上面面值相同
    }

枚举式(推荐使用)

/**
     * 枚举方法实现单例
     * JDK1.5中添加了枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
     */
    enum Singleton {
        INSTANCE;

        private void sayHello() {
            System.out.println("say ok~");
        }
    }

调用方法：

public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;
        System.out.println(singleton == singleton1);    // 输出ture
        System.out.println("singleton的hashCode：" + singleton.hashCode());  //hashCode值与下面值相同
        System.out.println("singleton1的hashCode：" + singleton1.hashCode()); //hashCode值与上面面值相同

        singleton.sayHello();
    }

单例模式注意事项和细节说明：

1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
2. 想要实例化一个单例类时，必须记住使用相应的获取对象方法，而不是使用new。
3. 单例模式使用场景：需要频繁创建和销毁的对象；创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源，session工厂等)；

JDK中单例模式的使用

JDK中，java.lang.RunTime使用了经典的单例模式(饿汉式)