标签：Singleton 模式 instance 线程 private 单例 static public

单例模式是什么？为什么要使用单例模式

单例模式，顾名思义就是在整个运行时域，一个类只有一个实例对象

为什么要用单例呢。因为有的类的，比较庞大和复杂，如果频繁创建和销毁对象，而且这些对象是可复用的话，就会造成不必要的性能浪费。

单例模式的写法？

多种写法，考虑三点：

1. 是否线程安全

2. 是否懒加载

3. 能否反射破坏

public class Singleton {
    //懒加载，线程不安全
    private static Singleton instance = null;
    
    private Singleton() {
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

上面的单例是线程不安全的，因为在执行if (instance == null)时，可能会有多个线程同时进入，从而实例化多次

那么如果把getInstance()的签名改成：public static synchronized Singleton getInstance() {} 可以吗？

这样确实能线程安全，但是我们只需要对象在构建的时候同步线程，上面时每次获取实例的时候都同步线程，开销极大 。

线程安全问题出现在了构建对象阶段，那么我们只要在编译器构建对象，在运行时调用，就不用考虑线程安全问题了，于是我们这么写：

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;
​
    private Singleton() {
    }
​
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if
                instance = new Singleton();
            }
        }
        return instance;
    }
}

但是这么写会有问题：可能有多个线程进入 if (instance == null) {} 代码块 ，虽然只有一个线程A能拿到锁，但是它一释放，线程B就会立即获取锁进行对象创建，对象就被创建了多次。

可以使用双检锁：

public class Singleton {
    private static Singleton instance = null;
​
    private Singleton() {
    }
​
    public static Singleton getInstance() {
        //双检锁
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

但是上面的写法也会遇到问题：

instance = new Singleton() 在指令层面并不是一个原子操作，而是分为三步：

1. 分配内存

2. 初始化对象

3. 对象指向内存地址

在真正执行时，JVM为了执行效率，可能会对指令重排，比如 1 3 2

如果按照这个顺序，A线程执行到了第三步，还未初始化。假设就在此时，线程B执行到了 if (instance == null)，false直接跳过，

返回instance导致对象未初始化。

解决办法：给instance加上volatile修饰

public class Singleton {
    //懒加载，线程安全
    //volatile修饰的变量不能被指令重排
    private volatile static Singleton instance = null;
​
    private Singleton() {
    }
​
    public static Singleton getInstance() {
        //双检锁
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

那有没有简单一点的写法呢：静态内部类

public class Singleton {
    //懒加载，线程安全
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
​
    private Singleton() {
    }
​
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

懒加载：静态内部类在程序启动的时候不会加载，只有第一次被调用的时候才会加载。

线程安全：多线程时，类加载机制能实现线程安全，因为loadClass方法使用了synchronized

上述写法都可以被反射破坏，因为反射可以获取到类的构造函数，包括私有构造函数，因此反射可以生成新的对象

单例模式之枚举实现 https://blog.csdn.net/lovelion/article/details/110983839

public enum Singleton {
    INSTANCE;
}

在实现过程中，Java虚拟机会保证枚举类型不能被反射并且构造函数只被执行一次

标签：Singleton,模式,instance,线程,private,单例,static,public
来源： https://www.cnblogs.com/WilsonEdwards/p/16641099.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。