设计模式之单例模式

一、核心作用：

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

二、优点：

1、由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决；
2、单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

三、应用场景：

1、Windows的Task Manager（任务管理器）就是很典型的单例模式；
2、Windows的Recycle Bin（回收站）也是典型的单例应用，在整个系统运行过程中，回收站一直维护着仅有的一个实例；
3、项目中，读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件数据，每次new一个对象去读取；
4、网站的计数器，一般也是采用单例模式实现，否则难以同步；
5、应用程序的日志应用，一般都采用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加；
6、数据连接池的设计一般也是采用单例模式，因为数据连接是一种数据库资源；
7、操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统；
8、在servlet编程中，每个Servlet也是单例；

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

主要：
-饿汉式（线程安全，调用效率高。但是，不能延时加载）
-懒汉式（线程安全，调用效率不高。但是，可以延时加载）
其它：
-双重检测式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
-静态内部类式（线程安全，调用效率高。但是，可以延时加载）
-枚举单例式（线程安全，调用效率高，不能延时加载）

五、代码(java实现)：

/**
 * 饿汉式单例模式
 *      线程安全，调用效率高。但是，不能延时加载
 * @author ly1
 *
 */
public class Singleton1 {

    private static Singleton1 instance  = new Singleton1();

    private Singleton1(){
    }

    public static Singleton1 getInstance(){
        return instance;
    }
}

/**
 * 懒汉式单例模式
 *      线程安全，调用效率不高。但是，可以延时加载
 * @author ly1
 *
 */
public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2(){
    }

    public static synchronized Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}

/**
 * 双重检测单例模式
 *      由于JVM底层内部模型原因，偶尔会出问题。不建议使用
 * @author ly1
 *
 */
public class Singleton3 {

    private static Singleton3 instance;

    private Singleton3(){
    }

    public static Singleton3 getInstance(){
        if(instance == null){
            synchronized(Singleton3.class){
                if(instance == null){
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

/**
 * 静态内部类单例模式
 *      线程安全，调用效率高，可以延时加载，结合了饿汉式与懒汉式的优点
 * @author ly1
 *
 */
public class Singleton4 {

    private static class Holder{
        private static final Singleton4 instance = new Singleton4();
    }

    public Singleton4 getInstance(){
        return Holder.instance;
    }

    private Singleton4(){
    }
}

/**
 * 枚举实现单例模式
 *      线程安全，调用效率高，不能延时加载。JVM底层保证单例。
 * @author ly1
 *
 */
public enum Singleton5 {
    INSTANCE;

    //其它操作
    private void operation(){
    }
}

/**
 * 单例模式的测试，这里只测试第一个饿汉式单例模式
 * @author ly1
 *
 */
public class Client {
    public static void main(String[] args) {
        Singleton1 s1 = Singleton1.getInstance();
        Singleton1 s2 = Singleton1.getInstance();

        System.out.println(s1 == s2);
    }
}

结果：true

六、五种单例模式调用效率的测试：

/**
 * 测试五种单例模式的调用效率,这里测的是第一种，其它的类似
 * @author ly1
 *
 */
public class PerformanceTest {
    public static void main(String[] args) throws Exception {
        int threadNum = 10;
        //记录开始时间
        long start = System.currentTimeMillis();
        //管理线程
        final CountDownLatch count = new CountDownLatch(threadNum);
        //开启十个线程，每个线程调用1亿次
        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable(){

                @Override
                public void run() {
                    for (int j = 0; j < 100000000L; j++) {
                        Object obj = Singleton5.INSTANCE;
                    }

                    count.countDown();
                }

            }).start();
        }
        //保证main线程在这十个线程执行完后再执行
        count.await();
        //记录结束时间
        long end = System.currentTimeMillis();

        System.out.println("总耗时：" + (end - start) + "ms");

    }
}

测试结果：

方式	效率
饿汉式	100ms
懒汉式	37183ms
双重检测式	104ms
静态内部类式	99ms
枚举式	99ms

分析：

1、可以看出懒汉式由于在方法上加了同步锁，导致每次调用都要同步，性能大大降低。
2、如果创建对象资源耗时，要求延时加载，建议选择静态内部类式；
3、如果不要求延时加载，建议选择枚举式。

七、其他相关问题

以上五种方式，除了枚举式，其他的都可以用反射和反序列化破解，造成不是单例。
-反射，虽然构造器私有化，依然还是可以调用。（参考）
-反序列化，先将对象通过对象流写入到文件中，再用对象流读取，会创建新的对象。（关于对象流）
当然，写普通的项目，不用考虑这些，这里只是提一下。