单例模式

什么是单例模式

　　一个对象在应用程序中只存在一个。

单例实现原理

　　以java为例，私有构造器，一个私有的静态的本身实例，一个对外开放获取本身实例的静态公共方法。

多种不同的方式实现单例

  饿汉式

　　在使用这个类时就初始化这个对象。

package com.lxlyq.singlePattern;

/**
 * 饿汉式单例
 */
public class HungrySingle {
    // 私有对象
    private static HungrySingle hungrySingle = new HungrySingle();
    // 私有构造，防止外部new
    private HungrySingle(){}
    // 外部调用
    public static HungrySingle getHungrySingle() {
        return hungrySingle;
    }
}

　　缺点：可能没有使用这个对象，但应用程序中也存在这个对象，浪费内存。

  懒汉式

　　只有获取这个实例时才初始化对象。

package com.lxlyq.singlePattern;

/**
 * 懒汉式
 */
public class LazySingle {
    // 私有对象 未初始化
    private static LazySingle lazySingle;
    // 私有构造 防止外部通过 new 创建
    private LazySingle() { }
    // 获取实例
    public static LazySingle getInstance() {
        // 不存在则创建
        if (lazySingle == null) {
            lazySingle = new LazySingle();
        }
        return lazySingle;
    }
}

　　优点：弥补了饿汉式的不足。

　　缺点：当存在多线程的时候将存在线程安全问题，两个线程同时进入if判断语句中，将会存在两个对象。

懒汉式同步方法锁

package com.lxlyq.singlePattern;

/**
 * 懒汉式(同步方法)
 */
public class LazySynchronizedMethodSingle {
    // 私有对象 未初始化
    private static LazySynchronizedMethodSingle lazySingle;
    // 私有构造 防止外部通过 new 创建
    private LazySynchronizedMethodSingle() { }
    // 获取实例 加上同步锁 防止多线程创建多个实例
    public static synchronized LazySynchronizedMethodSingle getInstance() {
        // 不存在则创建
        if (lazySingle == null) {
            lazySingle = new LazySynchronizedMethodSingle();
        }
        return lazySingle;
    }
}

　　优点：当获取时才创建实例，不存在线程安全问题。

　　缺点：每次获取实例时都需要加锁，效率极低。

懒汉式同步块锁

package com.lxlyq.singlePattern;

/**
 * 懒汉式同步块
 */
public class LazySynchronizedBlockSingle {
    // 私有对象 未初始化
    private static LazySynchronizedBlockSingle lazySingle;
    // 私有构造 防止外部通过 new 创建
    private LazySynchronizedBlockSingle() { }
    // 获取实例 加上同步块防止多线程创建多个实例
    public static  LazySynchronizedBlockSingle getInstance() {
        synchronized (LazySynchronizedBlockSingle.class) {
            // 不存在则创建
            if (lazySingle == null) {
                lazySingle = new LazySynchronizedBlockSingle();
            }
        }
        return lazySingle;
    }
}

　　与同步方法锁一样，效率也差不多，每次都需要加锁。需要改进如下

懒汉式双重校验同步块锁

package com.lxlyq.singlePattern;

/**
 * 懒汉式双重校验同步块
 */
public class LazyDoubleCheckSynchronizedBlockSingle {
    // 私有对象 未初始化
    private static LazyDoubleCheckSynchronizedBlockSingle lazySingle;
    // 私有构造 防止外部通过 new 创建
    private LazyDoubleCheckSynchronizedBlockSingle() { }
    // 获取实例 加上同步块防止多线程创建多个实例
    public static LazyDoubleCheckSynchronizedBlockSingle getInstance() {
        if (lazySingle == null) {
            // 第一次加锁，以后都不会再进入
            synchronized (LazyDoubleCheckSynchronizedBlockSingle.class) {
                // 不存在则创建
                if (lazySingle == null) {
                    lazySingle = new LazyDoubleCheckSynchronizedBlockSingle();
                }
            }
        }
        return lazySingle;

    }
}

　　优点：只有获取对象时才被创建。不存在线程安全问题。因为双重校验，只有当对象未被创建前才会被加锁，效率满足要求。

　　缺点：不符合审美（瞎扯）。

以上的真的都是单例了吗

　　// 通过反射破坏

package com.lxlyq.singlePattern;
import java.lang.reflect.Constructor;
public class SingleDemo {
    public static void main(String[] args) throws Exception {
        // 通过懒汉式双重校验获取实例
        LazyDoubleCheckSynchronizedBlockSingle single1 = LazyDoubleCheckSynchronizedBlockSingle.getInstance();
        System.out.println(single1);
        // 通过懒汉式双重校验获取实例
        LazyDoubleCheckSynchronizedBlockSingle single2 = LazyDoubleCheckSynchronizedBlockSingle.getInstance();
        System.out.println(single2);
        // 通过反射创建对象
        Class cls = LazyDoubleCheckSynchronizedBlockSingle.class;
        Constructor<?> cs = cls.getDeclaredConstructor();
        cs.setAccessible(true);
        LazyDoubleCheckSynchronizedBlockSingle single3 = (LazyDoubleCheckSynchronizedBlockSingle) cs.newInstance();
        System.out.println(single3);
        // out 
        // com.lxlyq.singlePattern.LazyDoubleCheckSynchronizedBlockSingle@4554617c
        // com.lxlyq.singlePattern.LazyDoubleCheckSynchronizedBlockSingle@4554617c
        // com.lxlyq.singlePattern.LazyDoubleCheckSynchronizedBlockSingle@74a14482
    }
}

　　之前所有的单例创建方式都存在通过反射破坏单例问题。

解决单例破坏问题

package com.lxlyq.singlePattern;

/**
 * 禁止通过反射创建单例
 */
public class BanReflexCreateSinge {
    // 采用饿汉式，但是客户端一样可以通过反射创建
    private static BanReflexCreateSinge banReflexCreateSinge = new BanReflexCreateSinge();
    // 防止反射
    private BanReflexCreateSinge(){
        if (banReflexCreateSinge != null) {
            throw new RuntimeException("禁止一切方法破坏单例");
        }
    }
    // 外部调用
    public static BanReflexCreateSinge getInstance() {
        return banReflexCreateSinge;
    }
}

　　通过这种反射，当系统中存在时就会抛出异常。

　　有一种通过枚举方式创建单例，枚举的底层也是这个原理。

　　这里没有介绍通过枚举创建单例，是我觉得枚举没有类那么灵活，尽管枚举是创建单例的最好方式，但不是最好的方案。

静态内部内实现单例

package com.lxlyq.singlePattern;

/**
 * 内部类创建单例
 */
public class LazyInnerClassSingle {
    // 防止外部调用
    private LazyInnerClassSingle(){}
    // 静态内部类
    private static class LazyInnerClass{
        private static LazyInnerClassSingle lazyInnerClassSingle = new LazyInnerClassSingle();
    }
    // 获取实例
    public static LazyInnerClassSingle getInstance() {
        return LazyInnerClass.lazyInnerClassSingle;
    }
}

　　这种方式，没有加锁，但也是懒汉式，代码简洁，推荐使用。

总结

  单例优点：

• 系统中只存在一个，减少内存开支，当一个对象需要被频繁创建销毁时，把它作为单例效果将极其明显。
• 系统多次需要使用一个对象时，把他设为单例可以减少系统开支。（如读取的配置信息）。
• 单例可以防止资源被多重占用，如读写文件。 

   单例缺点：

• 不适用于变化的对象
• 一般单例的职责都过重，违背了'单一原则'(一个类负责一件事)
• 单例没有抽象层，难以扩展。