核心作用:

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

常见应用场景:

• Windows的Task Manager(任务管理器)就是很典型的单例模式。
• Windows的Recycle Bin(回收站)也是典型的单利应用;在整个系统运行过程中,回收站一直维护着仅有的一个实例。
• 项目中,读取配置文件的类,一般也只有一个对象;没有必要每次使用配置文件数据,每次new一个对象去读取。
• 网站的计数器,一般也是采用单例模式实现,否则难以同步。
• 应用程序的日志应用,一般都用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。
• 数据库连接池的设计一般也是采用单例模式,因为数据库连接是一种数据库资源。
• 操作系统的文件系统,也是大的单例模式实现的具体例子,一个操作系统只能有一个文件系统。
• Application也是单例的典型应用(Servlet编程中会涉及)。
• 在Spring中,每个Bean默认就是单例的,这样做的优点是Spring容器可以管理。
• 在servlet编程中,每个Servlet也是单例。
• 在SpringMVC框架/struts1框架中,控制器对象也是单例。

单例模式的优点:

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

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

主要：

• 饿汉式(线程安全,调用效率高。但是,不能延时加载。)
• 懒汉式(线程安全,调用效率不高。但是,可以延时加载。)

其他:

• 双重检测锁式(由于JVM底层内部模型原因,偶尔会出现问题;不建议使用)
• 静态内部类式(线程安全,调用效率高。可以延时加载)
• 枚举单例(线程安全,调用效率高,不能延时加载)

如何选用

• 单例对象 占用 资源少,不需要延时加载:
  枚举式　好于　饿汉式
• 单例对象 占用资源大,需要延时加载:
  静态内部类　好于　懒汉式

饿汉式实现

package singleton;

public class SingletonDemo01 {
    private static SingletonDemo01 instance = new SingletonDemo01();
    private SingletonDemo01(){}

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

• 饿汉式单例模式代码中,static变量会在类装载时初始化,此时也不会涉及多个线程对象访问该对象的问题;虚拟机只会装载一次该类,肯定不会发生并发访问的问题;因此,可以省略synchronized关键字。
• 问题:如果只是加载本类,而不是要调用getInstance(),甚至永远没有调用,则会造成资源浪费!

懒汉式实现(单例对象延迟加载)

package singleton;

public class SingletonDemo02 {
    private static SingletonDemo02 instance;

    private SingletonDemo02(){}

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

• 要点:延迟加载,懒加载!真正用的时候才加载!
• 问题:资源利用率高了。但是,每次调用getInstance()方法都要同步,并发效率较低。

双重检测锁实现

package singleton;

public class SingletonDemo03 {
    private static SingletonDemo03 instance = null;

    private SingletonDemo03(){}

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

• 这个模式将同步内容下放到if内部,提高了执行的效率,比每次获取对象时都进行同步,只有第一次才同步创建了以后就没必要了
• 问题:由于编译器优化原因和JVM底层内部模型原因,偶尔会出现问题;不建议使用

静态内部类实现方式

package singleton;

public class SingletonDemo04 {
    private SingletonDemo04(){}

    private static class SingletonClassInstance{
        private static final SingletonDemo04 instance = new SingletonDemo04();
    }

    public static SingletonDemo04 getInstance(){
        return SingletonClassInstance.instance;
    }
}

• 要点:
  外部类没有static属性,则不会像饿汉式那样立即加载对象。
  只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。instance是static final类型,保证了内存中只有这样一个实例存在,而且只能被赋值一次,从而保证了线程安全性。
  兼备了并发高效调用和延迟加载的优势!

使用枚举实现单例模式

• 优点:
  实现简单
  枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞创建新对象！
• 缺点:
  无延迟加载

问题:

• 反射可以破解上面几种(不包含枚举式)实现方式!(可以在构造方法中手动抛出异常来控制)
• 反序列化可以破解上面几种(不包含枚举式)实现方式!可以通过定义readResolve()防止获得不同对象

package singleton;

import java.io.Serializable;

public class SingletonDemo06 implements Serializable{
    private static SingletonDemo06 instance;

    private SingletonDemo06(){
        // 防止反射破解单例
        if (instance != null){
            throw new RuntimeException();
        }
    }

    //方法同步 效率低
    public static synchronized SingletonDemo06 getInstance(){
        if (instance == null){
            instance = new SingletonDemo06();
        }
        return instance;
    }

    //反序列化时,如果定义了readResolve()则直接返回此方法指定的对象,而不会创建新对象
    private Object readResolve(){
        return instance;
    }
}

CountDownLatch

• 同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待;
  countDown()当线程调此方法,则计数减一(减一放在finally里执行)
  await()调用此方法会一直阻塞当前线程,直到计时器的值为0

package singleton;

import java.util.concurrent.CountDownLatch;

/**
 * @Description:测试多线程环境下五种创建单例模式的效率
 */
public class Client3 {
    public static void main(String[] args) throws Exception{
        long start = System.currentTimeMillis();

        Integer threadNum = 10;
        final CountDownLatch countDownLatch = new CountDownLatch(threadNum);

        for (int i=0;i<10;i++){
            new Thread(new Runnable() {
                public void run() {
                    for (int i=0;i<1000000;i++){
                        Object o = SingletonDemo04.getInstance();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();     //main线程阻塞,直到计数器为0,才会继续往下走

        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));
    }
}