单例设计模式详解

图片.png

单例设计模式需求：有一个类A和一个类B它们共享配置文件的信息，配置文件类ConfigFile中存在共享的数据Num1，Num2，Num3等；

类A中修改ConfigFile中数据，在类A中应该有如下代码

ConfigFile configFile=new ConfigFile();
configFile. Num1=2

这个时候configFile中的Num1=2，但是请注意这里是new ConfigFile是一个对象，想象一下在进行了上述操作后类B中进行如下操作

ConfigFile configFile=new ConfigFile();
System. out.println("configFile.Num1=" +configFile.Num1);

它打印的结果是这样的：configFile.Num1=1;
也就是说因为每次调用都创建了一个ConfigFile对象，所以导致了在类A中的修改并不会真正改变ConfigFile中的值，它所更改的只是在类A中说创建的那个对象的值.

现在要求在类A中修改数据后，要通知类B，即在类A和类B中操作的数据是同一个数据，类A改变一个数据，类B也会得到这个数据，并在类A修改后的基础上进行操作,方法有两个：,
第一个：把ConfigFile中的数据设置为静态，但是静态数据的生命周期是很长的，假如ConfigFile中有很多数据时，如果将其全部设成静态的，那将是对内存的极大损耗。所以全部设置成静态虽然可行但并不是一个很好的解决方法。
第二个：单例设计方法
两种常用方法：
1.饿汉式创建单例类
优点：类加载的时候就完成了实例化，避免了线程的同步问题。
缺点：类加载的时候就实例化，造成内存的浪费。

package st.test9;
//饿汉式创建单例类
public class Person {
    //私有构造方法,只能在自己内部供自己去访问
    private Person() {};
    //对构造方法引用,同时在自己内部定义自己的一个实例
    private static Person p =new Person();

    //此静态方法供外部直接访问
    public static Person getInstance() {
        return p;
    }
}

2.懒汉式双重校验锁创建单例类
优点：线程安全；延迟加载；效率较高。

package st.test9;
/*
 * 懒汉式创建单例类--双重校验锁
 * 二次判断的语法现象:
 *  外层的判断是为了效率
 *  内层的判断是为了保证单例对象只有一个.
 */
public class Student {
    //私有构造方法
    private Student() {}
    //
    private static Student s;
    //
    public static Student  getInstance() {
        if(s==null) {
        synchronized (Student.class) {
            if(s==null) {
                s= new Student();
            }
        }
    }
        return s;
    }
}

3.内部类

public class Singleton{
    private Singleton() {};
    private static class SingletonHolder{
        private static Singleton instance=new Singleton();
    } 
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

Singleton instance = Singleton.getInstance();

4.枚举

public enum SingletonEnum {
    
     instance; 
     
     private SingletonEnum() {}
     
     public void method(){
     }
}

SingletonEnum.instance.method();

GetInstance与new区别：
new的使用:如Object object = new Object()，这时候，就必须要知道有第二个public的Object构造方法的存在。

GetInstance的使用:在主函数开始时调用，返回一个实例化对象，此对象是static的，在内存中保留着它
的引用，即内存中有一块区域专门用来存放静态方法和变量，可以直接使用，调用多次返回同一个对象。

(1)对象使用之前通过getinstance得到，而不需要自己定义，用完之后不需要delete；
(2)new 一定要生成一个新对象，分配内存；getInstance() 则不一定要再次创建，它可以把一个已存在的
引用给你使用，这在效能上优于new；
(3) new创建后只能当次使用，而getInstance()可以跨栈区域使用，或者远程跨区域使用。所以getInstance()
通常是创建static静态实例方法的。
https://blog.csdn.net/dmk877/article/details/50311791