设计模式之单例模式

0.单例模式的封装

转自: http://blog.csdn.net/dingjikerbo/article/details/50617459

比如有一个God类,代码如下

public class God {
}

封装完以后拿到单例的方法很简单

God g1 = SingletonManager.god_instance.get();

需要的2个类

/**
 * 单例抽象类,不需要做任何修改
 */
public abstract class Singleton<T> {
    private T instance;

    /** 抽象方法,在SingletonManager 中实现即可,直接return new T(); */
    protected abstract T create();

    public final T get() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = create();
                }
            }
        }
        return instance;
    }
}

/**
 * 单例管理类
 * 
 * <p>
 * 获取单例的方法 SingletonManager.god_instance.get()
 * 
 * <p>
 * 哪个类需要设置为单例,就在这个里面添加一个静态字段.不过,通过new 那个类还是可以拿到非单例实例的
 */
public class SingletonManager {
    /** God 类的单例方法 */
    public static final Singleton<God> god_instance = new Singleton<God>() {

        @Override
        protected God create() {
            return new God();
        }
    };

}

 

 

---

 

可以说单例模式是所有设计模式中最简单的一种。

单例模式就是说系统中对于某类的只能有一个对象，不可能出来第二个。

单例模式也是23中设计模式中在面试时少数几个会要求写代码的模式之一。主要考察的是多线程下面单例模式的线程安全性问题。

1.多线程安全单例模式实例一(不使用同步锁)--恶汉式

缺点是该类加载的时候就会直接new 一个静态对象出来，当系统中这样的类较多时，会使得启动速度变慢 。现在流行的设计都是讲“延迟加载”，我们可以在第一次使用的时候才初始化第一个该类对象。所以这种适合在小系统。

public class God {
    private static God god=new God();//直接初始化一个实例
    private God() {//构造方法私有化,不允许直接new 对象
    }
    public static God getInstance(){//该类唯一的一个public方法
        return god;
    }
}

 

2.多线程安全单例模式实例二(使用同步方法)--懒汉式

public class God {
    private static God god;
    private God() {// 构造方法私有化,不允许直接new 对象
    }
    public static synchronized God getInstance() {// 对获取实例的方法进行同步
        if(god==null){
            god=new God();
        }
        return god;
    }
}

上述代码中的一次锁住了一个方法， 这个粒度有点大 ，改进就是只锁住其中的new语句就OK。就是所谓的“双重锁”机制。

 

3.多线程安全单例模式实例三(使用双重同步锁)

public class God {
    private static God god;
    private God() {// 构造方法私有化,不允许直接new 对象
    }
    public static  God getInstance() {// 对获取实例的方法进行同步
        if (god == null) {
            synchronized (God.class) {//双重锁,只锁定new方法
　　　　　　　　 if (god == null) {
                　　god = new God();
　　　　　　　　 }
            }
        }
        return god;
    }
}

 4.使用内部类的方式,既没有线程安全的隐患,也没有同步造成的性能影响

public class God {
    private God() {
    }

    private static class Holder {
        private static final God instance = new God();
    }

    public static God getInstance() {
        return Holder.instance;
    }
}

 

参考：http://www.cnblogs.com/xudong-bupt/p/3433643.html