单例设计模式

单例设计模式
问题：
可以保证一个类在内存里面的对象的唯一性
例子：
现在有a程序，b程序，有一些配置信息。现在要把这些信息分装到对象里面去。a现在要操作这些配置信息，现在操作完成以后，还必须在b程序重新建立一个新的对象的时候就已经知道，配置信息中的某些变量或是其他数据已经被改变了
实现：
<1>如果采用全静态的话，就会导致对象的生命周期过长
<2>实现过程：
a.不允许其他部分的程序用new创建对象，这样可以保证不用new创建更多的对象，私有化该类的构造函数
b.在该类中创建一个本类实例，通过new在本类中创建一个本类的对象
c.对外提供一个方法让其他程序可以获取该对象，定义一个公有的方法将创建的对象返回
示例代码：
1.饿汉式

class Single
{
    private static Single s = new Single();
   //在类中建立一个私有的本类的对象

    private Single() {}
   //建立一个私有的构造函数，防止别的类new新的对象

    public static  Single getIntance()
    {
        return s;
    }
    //提供对外进行访问的方法

}

随着类的加载，对象就已经存在了，被称为懒汉式

2.懒汉式
可以更加的减少对内存的占用（延迟加载形式）
示例代码：

class Single
{
   private static Single2 s = null;
   //将你的本类对象设置为空，以便于后面进行再加载
   private Single2() {}
   //设置私有构造函数防止被其他的方法重新建立对象
   public static Single2 getIntance()
   {
      if(s == null)
         s = new Single2();
      return s;
    }
    //做的是一个对象有没有被创建的判断
}        

这个是只有你真正需要这个对象的时候，对象才会被创建，这样的话会减少内存空间的消耗

---

在开发中使用上一种名叫“饿汉式”的开发模式，原因是不管你是提前加载还是后加载，终归都要进行加载，否则你这个设计模式就没有意义，而且使用后一种“懒汉式”在多线程开发的时候，容易导致类的对象不唯一

3.2.在多线程中的单例设计模式
判断多线程的访问问题：
是不是创建多个对象
是不是共享数据
在单例设计模式中是存在这样的问题的
示例代码：

class Single2
{
    private static  Single2 s = null;

    private Single2()
    {}

    public static synchronized Single2 getIntence()
    {
        if( s == null)
          s =   new Single2();
        return s;
    }
}
//加了同步之后就不会继续产生有可能新创建对象的事情

在这个地方使用同步函数每次都要重复的判断锁，效率比较低

4.使用同步代码块的放大来使单例设计模式同步提高效率
示例代码：

class Single2
{
    private static  Single2 s = null;

    private Single2()
    {}

    public static  Single2 getIntence()
    {
        if(s == null)
        {
           synchronized(Single2.class)
           {
              if( s == null)
              s = new Single2();

        }
        }
        return s;
    }
}

在函数体中使用了两次判断的目的就是，第一次线程进入使用了锁，然后失去了执行权，接着第二个线程进入，一看锁已经被使用就不再进入，等轮到第一个线程继续执行的时候，再把锁交还回来，减少判断次数