GOF23设计模式之单例模式（singleton）

一、单例模式概述

　　保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

　　由于单例模式只生成一个实例，减少了系统性能开销。所以当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

　　单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，复制所有数据表的映射处理。

　　1. 懒汉式

　　　　1)线程不安全

　　　　① 构造器私有化，避免外部直接创建对象

　　　　② 声明一个私有的静态属性

　　　　③ 对外创建一个公共的静态方法访问该属性

　　　　　　如果属性没有该对象，创建该对象

　　　　2)线程安全 

　　　　　　使用同步方法

　　　　3)双重检测（线程安全）double checking DCL

　　　　　　使用同步块

　　　　　　好处：第一次是为了不必要的同步，第二次是在属性等于null的情况下才创建实例
　　2. 饿汉式

　　　　① 构造器私有化，避免外部直接创建对象

　　　　② 声明一个私有的静态属性，同时创建该对象

　　　　③ 对外创建一个公共的静态方法访问该属性

　　　　　　好处：类加载时就已经加载该类对象，当需要该对象时，若没有则创建，若有直接返回

　　3. 静态内部类

　　　　① 构造器私有化，避免外部直接创建对象

　　　　② 使用静态内部类声明一个私有的静态属性，同时创建该对象

　　　　③ 对外创建一个公共的静态方法访问该属性

　　　　　　好处：不调用静态方法不加载内部类，延缓加载，提高效率

　　4.枚举

　　　　枚举式 （jdk1.4及以前建议使用）

二、单例模式的五种写法

　　1.饿汉式

　　　　优点：线程安全，效率高

　　　　缺点：无法延时加载

public class Singleton {
    
    private static Singleton instance = new Singleton();
    
    //私有化构造器
    private Singleton() {}

    //提供全局访问点
    public static Singleton getInstance() {
        return instance;
    }
    
}

public class Singleton {
    
    private static Singleton instance = null;
    
    static {
        instance = new Singleton();
    }
    
    //私有化构造器
    private Singleton() {}

    //提供全局访问点
    public static Singleton getInstance() {
        return instance;
    }
    
}

　　2. 懒汉式

　　　　优点：线程安全，延时加载

　　　　缺点：效率较低

　　　　（1）非线程安全

public class Singleton {
    
    private static Singleton instance;
    
    //私有化构造器
    private Singleton() {}

    //提供一个全局的访问点
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
}

　　　　（2）线程安全

public class Singleton {
    
    private static Singleton instance;
    
    //私有化构造器
    private Singleton() {}

    //使用同步方法获取该类对象
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
}

public class Singleton {
    
    private static Singleton instance;
    
    //私有化构造器
    private Singleton() {}

    //使用同步块获取该类对象
    public static Singleton getInstance() {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
    
}

　　3.双重检查锁

　　　　注意：由于编译器优化和JVM底层内部模型原因，偶尔会出问题，不建议使用

　　　　优点：线程安全，延时加载

　　　　缺点：效率较低，会出错误

public class Singleton {
    
    private static Singleton instance;
    
    private Singleton() {}
    
    //第一次判断是为了避免不必要的同步，第二次判断是属性为null时创建实例
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

　　4.静态内部类式

　　　　不调用静态方法不加载内部类，延缓加载（懒加载），提高效率

　　　　优点：线程安全，延时加载，效率高

public class Singleton {
    
    //静态内部类
    private static class SingletonHolder {
        //final可加可不加，因为外部类的外部无法使用该内部类
        private static /*final*/ Singleton instance = new Singleton();
    }
    
    //私有化构造器
    private Singleton() {}

    //提供一个全局的访问点
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    
}

　　5.枚举

　　　　注意：建议使用

　　　　优点：实现简单，线程安全，效率高，由于JVM从根本上实现保障，避免反射和反序列化的漏洞

　　　　缺点：无延时加载

1 public enum Singleton {
2     //这个枚举元素，本身就是一个单例对象
3     INSTANCE;
4 }

三、测试五种单例模式的耗时问题

/**
    在多线程环境下测试使用单例设计模式时创建对象的耗时（100个线程创建10000个对象）
       饿汉式：15ms
       懒汉式：671ms
       双重检测锁：65ms
       静态内部类：23ms
       枚举：32ms
 * @author CL
 *
 */
public class TestRuntime {
    
    public static void main(String[] args) throws Exception {
        long start = System.currentTimeMillis();
        
        int threadNum = 100;
        final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        //匿名内部类
        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    for(int i = 0; i < 10000; i++) {
                            //依次测试
                            Object o1 = SingletonDemo01.getInstance();    //饿汉式
//                            Object o2 = SingletonDemo02.getInstance();    //懒汉式
//                            Object o3 = SingletonDemo03.getInstance();    //双重检查锁
//                            Object o4 = SingletonDemo04.getInstance();    //静态内部类
//                            Object o5 = SingletonDemo05.INSTANCE;        //枚举
                    }
                }
            }).start();
            countDownLatch.countDown();    //递减锁存器的计数，如果计数到达零，则释放所有等待的线程
        }
        
        countDownLatch.await();    //阻塞main线程，知道计数器为0才开始继续执行
        
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end - start)+"ms");
    }

}

　　注意，根据电脑配置等因素时间会有差异，但时间比大致相同。

　　如何选用单例模式？

　　　　（1）单例对象占用资源少，不需要延时加载时：枚举式好于饿汉式

　　　　（2）单例对象占用资源大，需要延时加载时：静态内部类式好于懒汉式

四、破解单例模式　

　　1.使用反序列化破解单例模式

　　　　步骤：（1）使用序列化将已经创建的对象写出到系统文件

　　    　　　　（2）使用反序列化读取文件中的对象

import java.io.Serializable;

/**
 * 使用反序列化破解单例模式
 * @author CL
 *
 */
public class Singleton implements Serializable {
    
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
    
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 测试反序列化破解单例模式
 * @author CL
 *
 */
public class TestSingleton {
    
    public static void main(String[] args) throws Exception {
        //先获得一个对象
        Singleton s01 = Singleton.getInstance();
        System.out.println("先获取的对象：" + s01);
        
        //（1）使用序列化将对象写出到系统文件
        String filePath = "C:\\file\\obj.txt";
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(filePath));
        oos.writeObject(s01);
        oos.flush();
        oos.close();
        
        //（2）使用反序列化读取文件中的对象
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(filePath));
        Singleton s02 = (Singleton) ois.readObject();
        ois.close();
        
        System.out.println("反序列化读取的对象：" + s02);
    }

}

　　控制台输出：

先获取的对象：com.caolei.singleton.Singleton@15db9742
反序列化读取的对象：com.caolei.singleton.Singleton@33909752

　　显然已经通过反序列化已经创建了新的对象，解决办法是在类中添加如下代码：

/**
 * 反序列化时，如果创建了readResolve()方法则直接返回已经创建好的对象，而不需要再重新创建新的对象
 * @return
 * @throws ObjectStreamException
 */
 private Object readResolve() throws ObjectStreamException {
     return instance;
 }

　　现在再测试：

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 使用反序列化破解单例模式
 * @author CL
 *
 */
public class Singleton implements Serializable {
    
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
    
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    
    //反序列化时，如果创建了readResolve()方法则直接返回已经创建好的对象，而不需要再重新创建新的对象
    private Object readResolve() throws ObjectStreamException {
        return SingletonHolder.instance;
    }
    
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 测试反序列化破解单例模式
 * @author CL
 *
 */
public class TestSingleton {
    
    public static void main(String[] args) throws Exception {
        //先获得一个对象
        Singleton s01 = Singleton.getInstance();
        System.out.println("先获取的对象：" + s01);
        
        //（1）使用序列化将对象写出到系统文件
        String filePath = "C:\\file\\obj.txt";
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(filePath));
        oos.writeObject(s01);
        oos.flush();
        oos.close();
        
        //（2）使用反序列化读取文件中的对象
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(filePath));
        Singleton s02 = (Singleton) ois.readObject();
        ois.close();
        
        System.out.println("反序列化读取的对象：" + s02);
    }

}

　　控制台输出：

先获取的对象：com.caolei.singleton.Singleton@15db9742
反序列化读取的对象：com.caolei.singleton.Singleton@15db9742

　　现在创建的对象是同一对象，避免了反序列化破解单例模式出现的问题。

　　2.使用反射破解单例模式

　　　　步骤：（1）获取对象

　　　　　　    （2）获取构造器

　　　　　　    （3）跳过安全检查

　　　　　　    （4）创建对象

/**
 * 使用反射破解单例模式
 * @author CL
 *
 */
public class Singleton {
    
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
    
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    
}

import java.lang.reflect.Constructor;

/**
 * 测试反射破解单例模式
 * @author CL
 *
 */
public class TestSingleton {

    public static void main(String[] args) throws Exception {
        Singleton s1 = Singleton.getInstance();
        System.out.println("先获取的对象：" + s1);

        //使用反射破解单例模式
        //（1）创建对象
        Class<Singleton> clazz = (Class<Singleton>) Class.forName("com.caolei.singleton.Singleton");
        //（2）获得构造器
        Constructor<Singleton> c = clazz.getDeclaredConstructor(null);
        //（3）跳过安全检查
        c.setAccessible(true);
        //（4）创建对象
        Singleton s2 = c.newInstance();
        
        System.out.println("反射获取的对象：" + s2);
    }
}

　　控制台输出：

先获取的对象：com.caolei.singleton.Singleton@15db9742
反射获取的对象：com.caolei.singleton.Singleton@6d06d69c

　　显然使用反射机制跳过安全检查通过私有的构造器创建了新的对象，解决办法是在私有的构造器中添加如下代码：

if (instance != null) {
    throw new RuntimeException();    //再次创建对象时抛出异常
}

　　现在再测试：

/**
 * 使用反射破解单例模式
 * @author CL
 *
 */
public class Singleton {
    
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
    
    private Singleton() {
        if (SingletonHolder.instance != null) {
            throw new RuntimeException();    //再次创建对象时抛出异常
        }
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    
}

import java.lang.reflect.Constructor;

/**
 * 测试反射破解单例模式
 * @author CL
 *
 */
public class TestSingleton {

    public static void main(String[] args) throws Exception {
        Singleton s1 = Singleton.getInstance();
        System.out.println("先获取的对象：" + s1);

        //使用反射破解单例模式
        //（1）创建对象
        Class<Singleton> clazz = (Class<Singleton>) Class.forName("com.caolei.singleton.Singleton");
        //（2）获得构造器
        Constructor<Singleton> c = clazz.getDeclaredConstructor(null);
        //（3）跳过安全检查
        c.setAccessible(true);
        //（4）创建对象
        Singleton s2 = c.newInstance();
        
        System.out.println("反射获取的对象：" + s2);
    }
}

　　控制台输出：

先获取的对象：com.caolei.singleton.Singleton@15db9742
Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:408)
    at com.caolei.singleton.TestSingleton.main(TestSingleton.java:24)
Caused by: java.lang.RuntimeException
    at com.caolei.singleton.Singleton.<init>(Singleton.java:16)
    ... 5 more

 五、单例模式常见的应用场景

　　（1）Windows的Task Manager（任务管理器）、Recycle Bin（回收站）、文件系统等都是典型的单例模式；

　　（2）在项目中，读取配置文件的类一般也只有一个对象，没有必要每次使用配件的数据时，都去new一个对象来获取；

　　（3）网站的计数器，一般也是采用单例模式实现，否则难以同步；

　　（4）数据库连接池的设计就是采用单例模式；

　　（5）在Spring中，每个Bean默认是单例的，便于Spring容器管理；

　　（6）每个Servlet都是单例的；

　　（7）………………