设计模式之单例模式

基本介绍

什么是单例模式？在正常情况下，我们创建对象是使用new来进行创建，这样创建会产生多个实例，使用单例模式，类从始至终只能有一个实例，这样能很大程度的减少系统资源的浪费。
所以在单例模式下，我们是不会使用new来创建对象的，所以我们会将构造方法私有化
单例模式由多种方式
1.饿汉式
2.懒汉式
3.双重检查
4.静态内部类
5.枚举

饿汉式

饿汉式是单例模式的一种，他的主要特点是写法简单，在类装载的时候就创建了对象，避免了线程同步的问题，他有两种写法
写法1：

public class Singleton01 {

    public static void main(String[] args) {
        // 测试
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
    }
}

// 饿汉式 静态变量
class Singleton{

    private final static Singleton singleton = new Singleton();

    // 1.私有化
    private Singleton(){
    }

    public static Singleton getSingleton(){
        return singleton;
    }

}

这种方式他在类装载的时候静态变量初始化实例，这样就可以只获取一个实例
写法2：

public class Singleton02 {
    public static void main(String[] args) {
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
    }
}

/**
 * 1.方式和1类似，只不过将类实例化过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块的代码，初始化类的实例，
 * 优缺点和1是一样的
 */
class Singleton{
    private static Singleton singleton;
    static {
        singleton = new Singleton();
    }
    private Singleton(){
    }
    public static Singleton getSingleton(){
        return singleton;
    }
}

总结
优点：他保证了对象唯一，线程的安全
缺点：他没有懒加载的机制，在类被装载的时候，他就进行了初始化，在一定程度上可能造成资源的浪费

懒汉式

懒汉式，顾名思义，他实现了懒加载的方式，但是他也出现了一定的问题
写法1：

public class Singleton03 {
    public static void main(String[] args) {
        // 单线程下
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
    }
}
class Singleton{
    private Singleton(){
    }

    private static Singleton singleton;

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

起到了懒加载的效果，但是只能在单线程下使用
如果在多线程下，一个线程进入了if判断语句块，还没来得及往下执行，另一个线程也通过这个判断语句，这时候会产生多个实例，所以在多线程环境下不可使用这种方式
结论：在实际开发中，不要使用这种方法

写法2

public class Singleton04 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance());
        System.out.println(Singleton.getInstance());
        System.out.println(Singleton.getInstance());
        System.out.println(Singleton.getInstance());
    }
}
class Singleton{
    private Singleton(){
    }

    private static Singleton singleton;

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

    private static Singleton singleton;

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

解决了线程不安全的问题
效率太低，每个线程在想获得类的实例时候，执行getSingleton方法都要进行同步，而其实这个方法只执行一次实例化就够了，后面的想获得该实例，直接返回就行了
方法进行同步效率太低，在实际开发中，不推荐使用这种方式

双重检查

双重检查锁是多线程开发中常使用到的，我们进行了两次if判断，这样就可以保证线程安全了
这样，实例化代码只用执行一次，后面再次访问是，判断一个if就可以直接返回对象，也避免了反复进行方法同步
线程安全；延迟加载，效率较高
结论：推荐使用这种单例设计模式

public class Singleton06 {
	public static void main(String[] args) {
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
        System.out.println(Singleton.getSingleton());
    }
}
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;
    }

}

静态内部类

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

public class Singleton06 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance());
        System.out.println(Singleton.getInstance());
        System.out.println(Singleton.getInstance());
        System.out.println(Singleton.getInstance());
    }
}
class Singleton{
    private Singleton(){
    }

    /**
     * 静态内部类在类初始化时不会执行
     */
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();
    }

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

枚举

public class Singleton08 {
    public static void main(String[] args) {
        System.out.println(Singleton.INSTANCE);
        System.out.println(Singleton.INSTANCE);
        System.out.println(Singleton.INSTANCE.hashCode());
        System.out.println(Singleton.INSTANCE.hashCode());

        Singleton.INSTANCE.sayOk();
        Singleton.INSTANCE.sayOk();
    }
}
enum Singleton{
    INSTANCE;
    public void sayOk(){
        System.out.println("say OK ");
    }
}

借助了jdk1.5添加的枚举来实现单例，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
推荐使用

总结

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