单例模式

单例模式8种创建方式

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

1.饿汉式（静态常量）

创建步骤

1. 构造器私有化（防止new）
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法
4. 代码实现

public class StaticVariableSingletonTest {

    /**
     * @param
     * @return void
     * @Description: 测试--饿汉式--静态变量
     * @author luoyong
     * @create 21:33 2019/9/7
     * @last modify by [LuoYong 21:33 2019/9/7 ]
     */
    @Test
    public void test() {
        StaticVariableSingleton singletonOne = StaticVariableSingleton.getInstance();
        StaticVariableSingleton singletonOTwo = StaticVariableSingleton.getInstance();
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}


class StaticVariableSingleton {

    /**
     * 1.构造器私有化, 外部不能new
     */
    private StaticVariableSingleton() {

    }

    /**
     * 2.本类内部创建对象实例
     */
    private final static StaticVariableSingleton instance = new StaticVariableSingleton();

    /**
     * @param
     * @return
     * @Description: 3 提供一个公有的静态方法，返回实例对象
     * @author luoyong
     * @create 21:33 2019/9/7
     * @last modify by [LuoYong 21:33 2019/9/7 ]
     */
    public static StaticVariableSingleton getInstance() {
        return instance;
    }

优点

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

缺点

$在类装载的时候就完成了实例化,没有达到LazyLoading的效果。如果类没有被使用过，会造成内存的浪费$

结论

$这种单例模式可用，可能操作内存的浪费。（如果确定这个类一定会使用到可以这样写）$

2.饿汉式（静态代码块）

创建步骤

1. 构造器私有化（防止new）
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法
4. 代码实现

public class StaticBlockSingletonTest {

    /**
     * @param
     * @return void
     * @Description: 饿汉式--静态代码块--测试
     * @author luoyong
     * @create 21:51 2019/9/7
     * @last modify by [LuoYong 21:51 2019/9/7 ]
     */
    @Test
    public void test() {
        Singleton singletonOne = Singleton.getInstance();
        Singleton singletonOTwo = Singleton.getInstance();
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}


/**
 * 饿汉式(静态变量)
 */
class Singleton {

    /**
     * 1.构造器私有化, 外部能new
     */
    private Singleton() {
    }
    
    /**
     * 2.本类内部创建对象实例
     */
    private static Singleton instance;

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

    /**
     * @param
     * @return
     * @Description: 3.提供一个公有的静态方法，返回实例对象
     * @author luoyong
     * @create 21:51 2019/9/7
     * @last modify by [LuoYong 21:51 2019/9/7 ]
     */
    public static Singleton getInstance() {
        return instance;
    }
}

优点缺点–>同饿汉式静态常量

3.懒汉式（线程不安全）

实现

/**
 * @author luoyong
 * @Description: 懒汉式--线程不安全
 * 起到了Lazy Loading的效果 但是只能在单线程下使用
 * 在多线程的环境下可能产生多个实例
 * 结论：在实际开发当中，不要使用这种方式
 * @create 2019-09-07 22:00
 * @last modify by [LuoYong 2019-09-07 22:00]
 **/
public class ThreadUnsafeSingletonTest {

    /**
     * @param
     * @return void
     * @Description: 懒汉式--线程不安全--测试
     * @author luoyong
     * @create 22:02 2019/9/7
     * @last modify by [LuoYong 22:02 2019/9/7 ]
     */
    @Test
    public void test() {
        System.out.println("懒汉式--线程不安全");
        Singleton singletonOne = Singleton.getInstance();
        Singleton singletonOTwo = Singleton.getInstance();
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}

class Singleton {

    /**
     * 1.构造器私有化, 外部能new
     */
    private Singleton() {

    }


    /**
     * 2.本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * @param
     * @return
     * @Description: 3.提供一个公有的静态方法，返回实例对象
     * 调用的时候创建
     * @author luoyong
     * @create 21:51 2019/9/7
     * @last modify by [LuoYong 21:51 2019/9/7 ]
     */
    public static Singleton getInstance() {
        if (null == instance) {
            instance = new Singleton();
        }
        return instance;
    }

优点

$起到了Lazy-Loading的效果，但是只能在单线程下使用$

缺点

$在多线程下，一个线程进入了if(null==instance)判断语句块，还未来得及往下执行$
$另一个线程也进入了这个判断语句块，这时便会产生多个实例$
$所以在多线程环境下不可使用这个方式$

结论

$在实际开发当中，不要使用这种方式$

4-5.懒汉式–线程安全（同步代码块、同步方法）

实现

/**
 * @author luoyong
 * @Description: 懒汉式--线程安全
 * 解决了线程安全的问题
 * 缺点--效率太低，每个线程想获取该类的实例的时候 getInstance都要同步。
 * 结论：在实际开发当中 不推荐使用这种方式
 * @create 2019-09-07 22:08
 * @last modify by [LuoYong 2019-09-07 22:08]
 **/
public class ThreadSafeSingletonTest {

    /**
     * @param
     * @return void
     * @Description: 懒汉式--线程安全--加入同步处理代码--测试
     * @author luoyong
     * @create 22:02 2019/9/7
     * @last modify by [LuoYong 22:02 2019/9/7 ]
     */
    @Test
    public void test() {
        System.out.println("懒汉式--线程安全");
        SingletonSafe singletonOne = SingletonSafe.getInstance();
        SingletonSafe singletonOTwo = SingletonSafe.getInstance();
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}


class SingletonSafe {

    /**
     * 构造器私有化, 外部能new
     */
    private SingletonSafe() {

    }


    /**
     * 本类内部创建对象实例
     */
    private static SingletonSafe instance;

    /**
     * @param
     * @return
     * @Description: 提供一个公有的静态方法，返回实例对象
     * 调用的时候创建
     * 加入同步处理的代码--解决线程安全问题
     * @author luoyong
     * @create 21:51 2019/9/7
     * @last modify by [LuoYong 21:51 2019/9/7 ]
     */
    public static synchronized SingletonSafe getInstance() {
        if (null == instance) {
            instance = new SingletonSafe();
        }
        return instance;
    }

    /**
     * @param
     * @return
     * @Description: 这种方本意是对第四种方式进行改进，改成同步产生实例的化的代码块
     * 缺点：这种方式不能保证线程同步。也可能产生多个实例
     * 结论：在实际开发当中，不能使用这种方式
     * @author luoyong
     * @create 22:21 2019/9/7
     * @last modify by [LuoYong 22:21 2019/9/7 ]
     */
    public static SingletonSafe getInstanceUnSafe() {
        if (null == instance) {
            synchronized (SingletonSafe.class) {
                instance = new SingletonSafe();
            }
        }
        return instance;
    }

同步方法优点

$解决了线程不安全的问题$

同步方法缺点

$效率太低，每个线程在想获取类的实例的时候，执行getInstance()方法都要进行同步$
$而其实这个方法只执行一次实例化代码就就够了，后面想要获取该实例，直接return就可以了，方法进行同步效率太低$

同步方法结论

$在实际开发中，不推荐使用这种方式$

同步代码块优点

$第四种方式的改进，同步效率太低$

同步代码块缺点

$这种同步并不能起到线程同步作用。跟第三种实现方式遇到的情形一致$
$假如一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例$

同步代码块结论

$在实际开发中，不能使用这种方式$

6.双重检查

实现

/**
 * @author luoyong
 * @Description: 懒汉式--双重检查
 * 在多线程开发当中经常使用到
 * 优点：线程安全 延迟加载 效率较高
 * 结论：在实际开发当中，推荐使用这种单例设计模式
 * @create 2019-09-07 22:28
 * @last modify by [LuoYong 2019-09-07 22:28]
 **/
public class DoubleCheckSingletonTest {

    /**
     * @param
     * @return void
     * @Description: 测试双重检查实现单例
     * @author luoyong
     * @create 22:35 2019/9/7
     * @last modify by [LuoYong 22:35 2019/9/7 ]
     */
    @Test
    public void test() {
        System.out.println("双重检查--线程安全和懒加载");
        Singleton singletonOne = Singleton.getInstance();
        Singleton singletonOTwo = Singleton.getInstance();
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}


class Singleton {

    private Singleton() {
    }

    /**
     * 本类内部创建对象实例
     * volatile
     * 1:保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的（实现可见性）
     * 2:禁止进行指令重排序。（实现有序性）
     * 3:只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性
     */
    private static volatile Singleton singleton;

    /**
     * @param
     * @return
     * @Description: 双重检查 既达到了线程安全，又实现了懒加载
     * @author luoyong
     * @create 22:21 2019/9/7
     * @last modify by [LuoYong 22:21 2019/9/7 ]
     */
    public static Singleton getInstance() {
        if (null == singleton) {
            synchronized (Singleton.class) {
                if (null == singleton) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

优点

$线程安全延迟加载效率较高$

结论

$在实际开发过程中，推荐使用这种单例设计模式$

7.静态内部类

实现

/**
 * @author luoyong
 * @Description: 静态内部类--创建单例
 * @create 2019-09-07 23:09
 * @last modify by [LuoYong 2019-09-07 23:09]
 **/
public class StaticInnerClassesSingletonTest {
    /**
     * @param
     * @return void
     * @Description: 静态内部类--创建单例--推荐
     * @author luoyong
     * @create 23:22 2019/9/7
     * @last modify by [LuoYong 23:22 2019/9/7 ]
     */
    @Test
    public void test() {
        System.out.println("静态内部类--线程安全和懒加载");
        StaticInnerSingleton singletonOne = StaticInnerSingleton.getInstance();
        StaticInnerSingleton singletonOTwo = StaticInnerSingleton.getInstance();
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}

class StaticInnerSingleton {

    private StaticInnerSingleton() {
    }


    /**
     * 静态内部类
     * 1：StaticInnerSingleton 在装载的时候不会装载StaticInnerSingletonInit
     * 2：jvm在装载类的时候是线程安全的
     * 类的静态属性只会在第一次加载的时候初始化
     * 推荐使用
     */
    private static class StaticInnerSingletonInit {
        private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
    }

    public static StaticInnerSingleton getInstance() {
        return StaticInnerSingletonInit.INSTANCE;
    }
}

优缺点说明

$1.这种方式采用了类装载的机制来保证初始化实例时只有一个线程$
$2.静态内部类方式在StaticInnerSingleton类被装载时并不会立即实例化。是在需要实例化时，调用getInstance方法，才会装载StaticInnerSingletonInit类，从而完成StaticInnerSingleton的实例化。$
$3.类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。$
$优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高$
$结论:推荐使用$

8.枚举

实现

/**
 * @author luoyong
 * @Description: 枚举--创建单例
 * 借助JDK 1.5当中添加的枚举来实现单例模式
 * 1：批量了多线程同步问题
 * 2：防止反序列化重新创建新的对象
 * 结论：推荐使用
 * @create 2019-09-07 23:20
 * @last modify by [LuoYong 2019-09-07 23:20]
 **/
public class EnumSingletonTest {
    @Test
    public void test() {
        System.out.println("枚举--线程安全和懒加载");
        EnumSingleton singletonOne = EnumSingleton.INSTANCE;
        EnumSingleton singletonOTwo = EnumSingleton.INSTANCE;
        //内存地址相同
        System.out.println(singletonOne == singletonOTwo);
        System.out.println("singletonOne.hashCode=" + singletonOne.hashCode());
        System.out.println("singletonOTwo.hashCode=" + singletonOTwo.hashCode());
    }
}


enum EnumSingleton {

    INSTANCE;

    private void show() {
        System.out.println("ok");
    }
}

优缺点说明

$1.这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象$
$这种方式是EffectiveJava作者JoshBloch提倡的方式$
$结论:推荐使用$

源码使用举例

单例模式在JDK 应用的源码分析

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

注意事项

$1.单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能$
$2.当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new$

使用场景

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