设计模式之单例模式

// 饿汉式的实现方式比较简单。
//         在类加载的时候，
//         instance 静态实例就已经创建并初始化好
public class IdGenerator_e {

  private static final IdGenerator_e idGenerator_e = new IdGenerator_e();

  public static IdGenerator_e get_Generator(){

    return idGenerator_e;
  }



}

//懶汉模式
public class IdGenerator_b {

    private static IdGenerator_b idGenerator_b;

    public static synchronized   IdGenerator_b get_Generator(){

        if (idGenerator_b == null){
         idGenerator_b =  new IdGenerator_b();
        }
        return idGenerator_b;
    }
}

//双重检测
public class IdGenerator_b {

    private static IdGenerator_b idGenerator_b;

    public static  IdGenerator_b get_Generator(){

        if (idGenerator_b == null){

            //双重检测：如果是第一次再锁，不是就放过，可以保证饿汉式的内存占用又可以保证多线程效率
            synchronized(IdGenerator_b.class){
                if (idGenerator_b == null){
                    idGenerator_b =  new IdGenerator_b();
                }
            }


        }
        return idGenerator_b;
    }
}

//SingletonHolder 是一个静态内部类，当外部类 IdGenerator 被加载的时候，并不会创建 SingletonHolder 实例对象。只有当调用 getInstance() 方法时，
// SingletonHolder 才会 被加载，这个时候才会创建 instance。insance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。所以，
// 这种实现方法既保证了线程安全，又能做到延迟加载。
public class IdGenerator_c {

  private static final IdGenerator_c idGenerator_e = new IdGenerator_c();

  public static IdGenerator_c get_Generator(){

    return SingletonHolder.idGenerator_e;
  }

  private static class SingletonHolder{

    private static final IdGenerator_c idGenerator_e = new IdGenerator_c();
  }

}

package 单例模式;
//基于枚举类型的单例实现。这种实现方式通过
//Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性
public enum IdGenerator_enum {
    SINGLETON,
    UUUAA;
    private String name = "谢广坤";
    private Integer age = 25;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}



//枚举本质上是一个java类,继承自Enum类,但是我们不能人为的继承Enum类。

public class Demo {

    public static void main(String[] args) {
        System.out.println(IdGenerator_enum.SINGLETON.getName());

    }

}
//我们看代码,我们定义一个枚举：
public enum Size {
    SMALL, MEDIUM, LARGE
}


//它被编译器编译后对应的java类就是这样：

public final class Size extends Enum<Size> {

    public static final Size SMALL = new Size("SMALL", 0);
    public static final Size MEDIUM = new Size("MEDIUM", 1);
    public static final Size LARGE = new Size("LARGE", 2);

    private Size(String name, int ordinal) {
        super(name, ordinal);
    }

}
//可以看到,之前在枚举体中定义的SMALL、MEDIUM、LARGE变成了公有静态常量，且类中的构造函数是私有的，这就解释了为什么可以用枚举来做单例模式了。