深入理解单例模式

最新推荐文章于 2021-11-11 09:06:35 发布

liujieLike

最新推荐文章于 2021-11-11 09:06:35 发布

阅读量108

点赞数

原文链接：https://blog.csdn.net/ren762201592/article/details/103179477

版权

本文链接： https://blog.csdn.net/ren762201592/article/details/103179477

            </div>
                                                <!--一个博主专栏付费入口-->
         
         <!--一个博主专栏付费入口结束-->
        <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-4a3473df85.css">
                                    <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-4a3473df85.css">
            <div class="htmledit_views" id="content_views">
                                        <p>单例模式---<br>

同时在内存中，只有一个对象存在。单例模式有两种实现方式：

1：懒汉式(延迟加载) 2：饿汉式

首先介绍恶汉模式，基本上不会用,初始化太多。

public class Student1 {

// 2：成员变量初始化本身对象
private static Student1 student = new Student1();

// 构造私有
private Student1() {}

// 3：对外提供公共方法获取对象
public static Student1 getSingletonInstance() {
return student;
}

public void sayHello(String name) {
System.out.println("hello," + name);
}
}

细品懒汉模式

第一种：存在线程安全问题，10个线程同时执行到红色就会产生线程问题
public class Student2 {
//1：构造私有
private Student2(){}
//2：定义私有静态成员变量，先不初始化
private static Student2 student = null;
//3：定义公开静态方法，获取本身对象
public static Student2 getSingletonInstance(){
//没有对象，再去创建
if (student == null) {
student = new Student2();
}
//有对象就返回已有对象
return student;
}
}
b)
第二种：synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降
public class Student3 {
private Student3(){}
private static Student3 student = null;
// 此处考验对synchronized知识点的掌握情况
public static synchronized Student3 getSingletonInstance(){
if (student == null) {
student = new Student3();
}
return student;
}
}
第三种：似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，
只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。
先看 JVM中的对象创建过程
            Student student = new Student();// 高级语言
            a）new关键字会触发Student类的类加载（如果已加载，则此步骤作废）
            b）根据Class对象中的信息，去开辟相应大小的内存空间。
            c）初始化Student对象，就是完成成员变量的初始化操作（到这一步，我们才能说该对象是可用的）
            d）将开辟出来的内存空间地址，赋值给栈空间的变量student
如果两行代码的执行顺序交换之后，不会影响最终的程序执行结果，那么JIT即时编译器会根据情况去进行指令重排序。
也就是说 c和d有可能发生先执行d再执行c。多线程下有可能会发生错误
public class Student4 {
private static Student4 student = null;
private Student4() {}
// 此处考验对synchronized知识点的掌握情况
public static Student4 getSingletonInstance() {
if (student == null) {
// 采用这种方式，对于对象的选择会有问题
// JVM优化机制：先分配内存空间，再初始化
synchronized (Student4.class) {
if (student == null) {
student = new Student4();
//student.setName("ss")
//new ---- 开辟JVM中堆空间---产生堆内存地址保存到栈内存的student引用中---创建对象
// 存在的问题：
}
}
}
return student;
}
第四种：终极版本堪称完美版本
volatile关键字的作用：
                一个是禁止指令重排序。
                另一个作用是禁止使用CPU缓存。
public class Student5 {
private volatile static Student5 student;
private Student5() {
}
public static Student5 getSingletonInstance() {
if (student == null) {
// B线程检测到student不为空
synchronized (Student5.class) {
if (student == null) {
student = new Student5();
// A线程被指令重排了，刚好先赋值了；但还没执行完构造函数。
}
}
}
return student;// 后面B线程执行时将引发：对象尚未初始化错误。
}
}