设计模式之单利模式

单利模式应该是开发中用的最多的一种。

单例设计模式目的：

解决一个类在内存中只存在一个对象

想要保证对象唯一，实现思路:

1.为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象

2.还为了其他程序可以访问到该类对象，只好在本类中自定义一个对象

3.为了方便其他程序对自定义对象的访问，可以对外提供访问方式

代码体现：
1.将构造函数私有化
2.在类中创建一个本类对象
3.提供一个方法，可以获取到该对象

方式一：饿汉式

<pre name="code" class="html"><pre name="code" class="java">//饿汉式
class Single
{
    private Single(){};
    private static Single s = new Single();
    public static Single getInstance()
    {
        //return new Single();  // 这样其实是每一次都创建一个新对象，不要混淆
        return s;
    }
}

class Test 
{
    public static void main(String[] args) 
    {
        Single ss = Single.getInstance();
    }
}

方式二 ：懒汉式

//懒汉式
class Single
{
    private Single(){};
    private static Single s = null;
    public static Single getInstance()
    {
        if(s == null)
              s = new Single();
         return s;
    }
}
classTest 
{
    public static void main(String[] args) 
    {
        Single ss = Single.getInstance();
    }
}

小结：

饿汉式：Single一进内存就创建好了对象，

懒汉式：Single进内存还没有存在，只有调用了getInstance方法时才建立对象

懒汉式是延迟加载

懒汉式延迟加载存在的问题： 如果多线程访问时会有线程安全问题

解决方案：

可以加同步来解决，加同步的方式用同步函数和同步代码块都行，但是稍微有些低效

用双重判断的方式能解决低效问题，稍微提高一点

此时同步的时候加的锁是:

该类所属的字节码对象

//懒汉式+多线程
class Single
{
    private Single(){};
    private static Single s = null;
    public static Single getInstance()
    {
        if (s==null)
        {
            synchronized(Single.class)
            {
                if (s==null)
                {
                    s = new Single();
                }
            }
        }
    }
}
class Test 
{

    public static void main(String[] args) 
    {
        Single ss = Single.getInstance();
        new Thread(ss).start();
        new Thread(ss).start();
    }
}