设计模式-单例模式

---

前言

单例模式的目的是需不需要在全局范围内只创建该类的对象实例，主要分为懒汉式和饿汉式。

---

提示：以下是具体实现，个中滋味可以自己体会

一、饿汉式写法

public class Student {
    //私有静态成员变量
    private static Student student = new Student();
    //私有构造类
    private Student(){}
    //开发静态成员方法获取静态成员变量
    public static Student createStudent(){
        return student;
    }
}

二、懒汉式写法一

public class Student1 {
    private static Student1 student = null;
    private Student1(){}
    private static Student1 createStudent(){
        if (student == null){
            student = new Student1();
        }
        return student;
    }
}

这里出现的问题就是两个线程同时进去if代码块的话会创建多余的对象造成资源浪费。

三、懒汉式写法二

public class Student2 {
    private static Student2 student = null;
    private Student2(){}
    private synchronized static Student2 createStudent(){
        if (student == null){
            student = new Student2();
        }
        return student;
    }
}

这里出现的问题是对方法直接上锁，会导致效率降低。

四、懒汉式写法三

public class Student3 {
    private static Student3 student = null;
    private Student3(){}
    private static Student3 createStudent(){
        if (student == null){
            synchronized (Student3.class){
                student = new Student3();
            }
        }
        return student;
    }
}

这里出现的问题是会存在if代码块存在2个线程都进去了。

五、懒汉式写法四

public class Student4 {
    private static Student4 student = null;
    private Student4(){}
    private static Student4 createStudent(){
        if (student == null){
            synchronized (Student4.class){
                if (student == null) {
                    student = new Student4();
                }
            }
        }
        return student;
    }
}

这里出现的问题是会存在在调用Student4里面的属性值的时候有可能存在原子性问题(理论中存在的)。

六、懒汉式写法五

public class Student5 {
    private volatile static Student5 student = null;
    private Student5(){}
    private static Student5 createStudent(){
        if (student == null){
            synchronized (Student5.class){
                if (student == null){
                    student = new Student5();
                }
            }
        }
        return student;
    }
}

这里直接利用volatile的有序性和可见性对整个代码进行了优化，至此结束。

七、懒汉式写法六

public class Student6 {
    private static Student6 student = null;
    private static class SingletonFactory{
        private static Student6  student = new Student6();
    }
    private static Student6 CreateStudent(){
        return SingletonFactory.student;
    }
}

这里直接利用静态内部类的互斥效果实现的。