单例模式

什么是单例模式

单例模式（Singleton Pattern）：确保某一个类只有一个实例，而且自行实例化并向整个系统提供该实例，这个类称为单例类，它提供全局访问的方法。

在传统的创建的类的代码当中，类的实例化都是由我们自己new的，也就是说能new几个就new几个。

public class Troditional {

    public static void main(String[] args) {
        Singleton singleton = new Singleton();
        Singleton singleton1 = new Singleton();
    }
}
/**
 * d单例类
 */
class Singleton{

}

在上述的代码中，我们每new一个类就会产生一个实例，很明显不符合单例的要求。所以需要对上述代码进行修改，具体如下：

/**
 * 恶汉式
 */
public class Hunger {
    public static void main(String[] args) {
        Singleton singleton = new Singleton();
        Singleton singleton1 = Singleton.getInstance();
    }
}
class Singleton{
    private Singleton(){}
    public static final Singleton singleton = new Singleton();
    public static Singleton getInstance(){
        return singleton;
    }
}

在这里我们将单例类的构造函数私有化，会发现我们我发通过new的方式去实例化该类，只能通过单例类所提供的实例化方法去获取类的实例。
这只是其中的一种单例写法，相应的还有懒汉式，代码如下：

/**
 * 懒汉式
 */
public class Lazy {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
    }
}
class Singleton{
    private Singleton(){}
    private static Singleton singleton = null;
    
    public static Singleton getInstance(){
        if(singleton ==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

以上就是懒汉式的代码，懒汉式具有延迟加载的特性，对于解决创建单例对象耗费过多资源来说是不错的选择。但显然懒汉式没有考虑到线程安全的问题， 在多线程并发的情况下，会并发的调用getInstance方法导致同时创建多个Singleton实例。这显然违背了单例的初衷，所以需要对上述代码进行修改，具体代码如下：

/**
 * 懒汉式加synchronized
 */
public class Lazy {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
    }
}
class Singleton{
    private Singleton(){}
    private static Singleton singleton = null;

    public static synchronized Singleton getInstance(){
        if(singleton ==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

通过添加synchronized锁解决了线程安全的问题，但是频繁的加锁解锁极大的消耗了系统资源。因此，需要对代码进行优化“双重校验锁”，代码如下：

/**
 * 懒汉式加双重校验锁
 */
public class Lazy {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
    }
}
class Singleton{
    private Singleton(){}
    private static Singleton singleton = null;

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

除了懒汉式和恶汉式外，还有一种单例模式的写法根据特色，也更加简洁明了。那就是静态内部类的单例模式。

/**
 * 静态内部类单例写法
 */
public class StaticClass {
     private static class SingleonHolder{
         private static  StaticClass singleton = new StaticClass();
     }    
    
     public static StaticClass getInstance(){
         return SingleonHolder.singleton;
     }
}

以上就是我说熟知的单例模式的写法，单例模式本身就是为了解决创建多个该对象无意义的场景的，就比如我们所熟知的电脑任务管理器，根本不需要多个一模一样的任务管理器的存在，那纯粹是浪费资源的。

详细请看：https://blog.csdn.net/qq_36413562/article/details/78768155