单例模式详解：饿汉式、懒汉式与线程安全-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_41362471/article/details/121778557

单例设计模式

分为两种：

1. 饿汉式

不管需不需要这个对象，只要类加载了，就把他创建出来。
不存在线程安全问题。

写法1：

/**
 * 单例模式 --> 饿汉式
 * 在类加载的时候就创建出这个对象，不管需不需要用到
 *
 * (1)构造器私有化
 * (2)使用类型进行调用
 */
public class Singleton1 {

    //构造器私有化
    private Singleton1(){}

    //使用静态变量提供这个类的实例 --> 这里的修饰符是public，这样才能通过外部类进行调用
    public static final Singleton1 INSTANCE = new Singleton1();
}

调用：

Singleton1 singleton1 = Singleton1.INSTANCE;
Singleton1 singleton2 = Singleton1.INSTANCE;
System.out.println(singleton1 == singleton2);  //true

写法2：直接使用枚举类型。枚举的构造器也是私有的，是单例的。

public enum Singleton2 {
    INSTANCE;
}

调用：

Singleton2 single = Singleton2.INSTANCE;

2. 懒汉式

延迟创建对象，只有调用到的时候才会创建这个对象。
存在线程安全问题。

写法1：

/**
 * 单例设计模式 --> 懒汉式，需要用到的时候才创建对象
 *
 * (1)构造器私有化
 * (2)提供一个静态方法来获取该类对象
 */
public class Singleton3 {
    //构造器私有化
    private Singleton3(){}

    //静态变量
    private static Singleton3 instance;

    //提供一个静态方法获取这个类对象
    public static Singleton3 getInstance(){
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }
}

调用：

Singleton3 singleton3 = Singleton3.getInstance();

上面的方法，在单线程下是没有问题的。但是在多线程的时候，就不一定是单例，是有问题的。如：有两个线程，在调用getInstance()方法的时候，线程1已经判断到instance是null，但是这个时候cpu的执行时间到了，切换到线程2，但是此时是还没创建的。线程2判断之后是null，创建了对象。然后回到线程1执行，又创建了一个对象，所以不是线程安全的。

写法2：

/**
 * 解决线程安全问题，使用 锁 的方式。即：同步代码块
 */
public class Singleton4 {
    //构造器私有化
    private Singleton4(){}

    //静态变量
    private static Singleton4 instance;

    //提供一个静态方法获取这个类对象
    public static Singleton4 getInstance(){
        //加同步锁，锁用这个类对象
        synchronized (Singleton4.class) {
            if (instance == null) {
                instance = new Singleton4();
            }
        }
        return instance;
    }
}

上面的方式解决了线程的安全问题，但是会有效率问题。比如：instance不是null的时候，不需要同步，直接返回就行了。所以有方法3.

写法3：

/**
 * 解决线程安全问题，使用 锁 的方式。即：同步代码块
 * 解决效率问题，多次判断。
 */
public class Singleton5 {
    //构造器私有化
    private Singleton5(){}

    //静态变量
    private static Singleton5 instance;

    //提供一个静态方法获取这个类对象
    public static Singleton5 getInstance(){
        //只有 instance == null 没有创建的时候，才需要进入加锁操作，不然直接返回这个类对象即可。
        if (instance == null) {
            //加同步锁，锁用这个类对象
            synchronized (Singleton5.class) {
                if (instance == null) {
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

上面的方式既解决了线程安全问题，又解决了效率问题，好，good的。
但是写起来不方便。

还可以使用静态内部类的方式。

写法4：

/**
 * 懒汉式：用到的时候再创建对象
 *
 * 使用静态内部类的方式。
 * 静态内部类是只有使用到的时候才会初始化里面的内容。
 */
public class Singleton6 {
    //构造方法私有化
    private Singleton6(){}

    //定义静态内部类
    private static class Inner{
        //创建这个对象，以供外部类获取
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    //对外提供公有方法
    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}

应用场景

(此部分内容引用自其它博客)
链接：单例模式的常见应用场景

Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？
注：这个我真的试了，打不开，只能打开一个
windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
网站的计数器，一般也是采用单例模式实现，否则难以同步。
注：这个也可以理解，你要统计这个网站有多少人访问，那肯定只能使用一个计数器，不然多个计数器，结果会偏小。
应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为用单例模式来维护，就可以大大降低这种损耗。
多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
HttpApplication 也是单例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.