黑马程序员_日记15_Java多线程（五）

　　——- android培训、java培训、期待与您交流！ ———-

单例设计模式

只允许建立一个对象的设计模式称之为单例设计模式。

饿汉式

饿汉式：是指已加载该类，就立刻建立对象。

//饿汉式
class HungryManSingle
{
    //建立引用，终身指向饿汉式创建的对象
    private static final HungryManSingle s = new HungryManSingle();

    //私有化构造函数
    private HungryManSingle(){}

    //提供获饿汉式取实例的办法
    public static HungryManSingle getInstance()
    {
        return s;
    }

}

注意：饿汉式在实际开发中用得比较多。

懒汉式

懒汉式：是指被调用的时候才建立对象，称之为延迟加载。

//懒汉式
class LazyManSingle
{
    //建立引用，并指向为空
    private static LazyManSingle s =null;

    //私有化构造函数
    private LazyManSingle(){}

    //提供懒汉式获取实例的办法
    public static LazyManSingle getInstance()
    {
        if(s==null)
            s = new LazyManSingle();

    }
}

上面这个懒汉式在多线程的时候，存在安全问题，
我们利用同步静态函数可以解决安全问题，
但是当线程很多的时候，访问锁的次数会非常多，效率太低。
在这里我们采用双重判断的方式来解决访问锁的次数。

//双重判断解决懒汉式的效率问题，同步代码块的方式来解决安全问题
class SynchronizedLazyManSingle
{
    //建立引用，指向为空
    private static SynchronizedLazyManSingle s = null;

    //私有化构造函数
    private  SynchronizedLazyManSingle(){}

    //提供安全高效地获取实例的方法
    public static  SynchronizedLazyManSingle getInstance()
    {
        if(s==null)
        {
                synchronized( SynchronizedLazyManSingle.class)//静态函数的同步锁是“类名.class"
                {
                    if(s==null)
                        s = new  SynchronizedLazyManSingle();
                }
        }
    }

}

小结

饿汉式—开发用
懒汉式–实例延迟加载–安全问题–同步锁–效率问题–双重判断
注意：懒汉式的锁是:类名.class