设计模式课时七------单例模式

单例模式

单体模式的不同变现形式：
1.饿汉单例模式
2.懒汉单例模式
3.多例模式

1.饿汉单例模式

public class Singleton {
    // 首先，将 new Singleton() 堵死
    private Singleton() {};
    // 创建私有静态实例，意味着这个类第一次使用的时候就会进行创建
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }
    // 瞎写一个静态方法。这里想说的是，如果我们只是要调用 Singleton.getDate(...)，
    // 本来是不想要生成 Singleton 实例的，不过没办法，已经生成了
    public static Date getDate(String mode) {return new Date();}
}

很多人都能说出饿汉模式的缺点，可是我觉得生产过程中，很少碰到这种情况：你定义了一个单例的类，不需要其实例，可是你却把一个或几个你会用到的静态方法塞到这个类中。

2.懒汉单例
//双锁模式（线程安全，效率低下，适合初次启动加载一次的）

public class Singleton {
    // 首先，也是先堵死 new Singleton() 这条路
    private Singleton() {}
    // 和饿汉模式相比，这边不需要先实例化出来，注意这里的 volatile，它是必须的
    private static volatile Singleton instance = null;
    public static Singleton getInstance() {
        if (instance == null) {
            // 加锁
            synchronized (Singleton.class) {
                // 这一次判断也是必须的，不然会有并发问题
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

//内部类模式

/**
 * 线程安全，效率高，并且实现延迟加载
 */
class lazy implements Serializable
{
    private static class SingletonCalssInstance
    {
        private static final lazy instance = new lazy();
    }
    private lazy()
    {
        //做一些防止反射暴力创建
        if ( SingletonCalssInstance.instance != null )
            throw new RuntimeException("单例禁止");
    }
    public static lazy getInstance()
    {
        return SingletonCalssInstance.instance;
    }

    //防止反序列化获取多个对象
    private Object readResolve() throws ObjectStreamException
    {
        return SingletonCalssInstance.instance;
    }

}

3.多例模式----双例

public class Many {

    private static Many many1 = new Many();
    private static Many many2 = new Many();
    private Many()
    {
    }
    public static Many getInstance (int whickOne)
    {
        if (whickOne == 1)
            return many1;
        else
            return many2;
    }
}