设计模式（一）------ 单例模式

1、设计模式分类

建立型模式
     - 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
结构型模式
    - 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
行为型模式
    - 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

2、单例模式

核心做用：保证一个类只有一个实例，而且提供一个访问该实例的全局访问点。

单例模式优势：因为单例模式只生成一个实例，减小系统性能开销，当一个对象的产生须要比较多的资源时，如读取配置文件，则能够经过在应用启动时直接产生一个单例对象，而后永久驻留在内存的方式解决。

常见的五种单例模式实现方式：

　　饿汉式（线程安全，调用效率高。可是不能延时加载）

　　懒汉式（线程安全，调用效率不高。可是能够延时加载）

　　双层检测锁式（因为JVM底层内部模型缘由，偶尔出现问题，不建议使用）

　　静态内部类式（线程安全、调用效率高，能够延时加载）

　　枚举单例（线程安全，调用效率高，不能延时加载，自然的防止反射和反序列化漏洞）

 

一、饿汉式

/** * 饿汉式单例模式 * static 变量会在类加载时初始化。JVM保证只会加载一次该类, 确定不会发生并发访问的问题 */
public class SingleDemo1 { // 类初始化时加载这个对象
    private static /*final*/ SingleDemo1 INSTANCE = new SingleDemo1(); // 构造方法私有
    private SingleDemo1() {} 
　　// 方法没有同步, 调用效率高 public static SingleDemo1 getInstance() { return INSTANCE; } }

 

二、懒汉式

/** * 懒汉式 * 延时加载, 资源利用率高； * getInstance() 增长同步方法, 调用效率低 */
public class SingleDemo2 { private static SingleDemo2 singleDemo2; // 构造方法私有化
    private SingleDemo2() {} // 加synchronized方法同步, 调用效率低
    public static synchronized SingleDemo2 getInstance() { if(null == singleDemo2) { singleDemo2 = new SingleDemo2(); } return singleDemo2; } }

 

三、双重检测锁模式

 

 四、静态内部类实现单例模式

/** * 静态内部类实现单例模式 * 线程安全, 懒加载, 调用效率高 */
public class SingleDemo3 { // 静态内部类
    private static class SingleDemoInner { //类初始化时加载, static final 保证内存中只有一个这样实例存在, 并且只能被赋值一次
        private static final SingleDemo3 INSTANCE = new SingleDemo3(); } // 构造方法私有化
    private SingleDemo3() {} // 没有同步, 调用效率高
    public static SingleDemo3 getInstance() { return SingleDemoInner.INSTANCE; } }

五、枚举类

/** * 枚举类实现单例模式 (不能延时加载) * 枚举是自然的单例, 由JVM从根本上提供保障; * 避免经过反射和反序列化的漏洞! */
public enum SingleDemo4 { // 定义一个枚举的元素, 它就表明了Singleton的一个实例
 INSTANCE; //单例能够有本身的操做
    public void singletonOperation() { //功能处理
 } }

 

六、使用反射或反序列化能够破解上面的懒汉式、饿汉式、双重检测锁模式（不建议使用）、静态内部类式实现的单例。

（1）测试反射破解：

/** * 测试反射破解 */
public class MainTest { public static void main(String[] args) throws Exception { // 经过反射方式构造多个对象
        Class<SingleDemo1> clazz = (Class<SingleDemo1>) Class.forName("com.yufeng.single.SingleDemo1"); Constructor<SingleDemo1> constructor= clazz.getDeclaredConstructor(null); constructor.setAccessible(true); //跳过权限检查
 SingleDemo1 demo3 = constructor.newInstance(); SingleDemo1 demo4 = constructor.newInstance(); System.out.println(demo3); System.out.println(demo4); } }

结果：

　　com.yufeng.single.SingleDemo1@14ae5a5
　　com.yufeng.single.SingleDemo1@7f31245a

（2）测试反序列化破解（SingleDemo1 实现 Serializable 接口）

/** * 测试反序列化破解 */
public class MainTest { public static void main(String[] args) throws Exception { // 经过反序列化构造多个对象
        SingleDemo1 a1 = SingleDemo1.getInstance(); //序列化的类要实现 Serializable 接口 System.out.println(a1); //序列化
        FileOutputStream fos = new FileOutputStream("d:/a.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(a1); oos.close(); fos.close(); //反序列化
        FileInputStream fis = new FileInputStream("d:/a.txt"); ObjectInputStream ois = new ObjectInputStream(fis); SingleDemo1 a2 = (SingleDemo1) ois.readObject(); System.out.println(a2); } }

 

 解决反射和反序列化破解单例的问题

以懒汉式为例，以下：

/** * 解决反射和反序列化破解单例的问题 */
public class SingleDemo5 implements Serializable { private static /*final*/ SingleDemo5 INSTANCE = new SingleDemo5(); // 构造方法私有
    private SingleDemo5() { //防止反射破坏单例 能够在构造方法中手动抛出异常，解决反射破解的问题
        if(null != INSTANCE) { throw new RuntimeException("单例模式, 不可以使用反射建立实例."); } } // 方法没有同步, 调用效率高
    public static SingleDemo5 getInstance() { return INSTANCE; } 
 // 能够经过readResolve()方法防止反序列得到到不一样的对象 // 反序列化时, 若定义了readReolve()方法, 直接返回此方法指定的对象, 而不须要再单首创建新对象
    private Object readResolve() throws ObjectStreamException { return INSTANCE; } }

 

 3、五种实现方式在多线程下的效率