23种设计模式之一 ----- 单例模式

所谓单例模式就是 确保某个类只有一个实例，而且自行实例化，并且向系统提供这个实例

一 。 单例的优点，由于内存中只有一个单例，减少了内存开支，对系统的性能开支

 /*
 * 这个方法实现单例 是比较好的，确保只能有一个实例
 */
public class Emperor {
    public static final Emperor emperor = new Emperor();
    //限制多个对象
   private Emperor(){

   }
    //提供实例
    public static Emperor getInstance(){
        return emperor;
    }
    public static void say(){
        System.out.println("i am king");
    }
}

二 。 线程不安全的单例

/***
 * 线程不安全的实例
 * 此方法，有可能有出现多个该类的实例
 * 如果 线程 A 执行到 singleton = new Singleton(),但还没有获得到对象（对象初始化时需要时间的），
 * 线程 B 也执行到，（singleton == null）的判断，那么线程 B 获得的判断条件也是真，于是继续执行下去
 * 线程 A,B 都获取到了该类的实例，内存中出现两个对象
 *
 */
public class Singleton {
    private static  Singleton singleton = null;
   //限制多个对象
    private void Singleton(){

    }
    //通过刚方法获得实例对象
    public  static Singleton getSingleton(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return  singleton;
    }

}

三 。单例模式的扩展，有上限的多例模式

/***
 *单例模式的扩展，有上限的多例模式 ，此处实现两个实例
 *
 */
public class EmperorMore {
    //产生2个实例
    private static int NumOfEmperor = 2;
    //名字集合
    private static ArrayList<String> nameList = new ArrayList<String>();
    //当前类的实例
    private static ArrayList<EmperorMore> emperoror = new ArrayList<EmperorMore>();
    //当前类的序列号
    private static int CurrentNumber = 0;

    private EmperorMore(){

    }
    //传入名称，创建类的实例
    private EmperorMore(String name){
        nameList.add(name);
    }
    //产生所有的对象
    static {
        for (int i = 0; i < NumOfEmperor; i++) {
            emperoror.add(new EmperorMore((i+1)+" 皇帝"));
        }
    }
    //随机获取该类的实例
    public static EmperorMore getEmperorMoreInstance(){
        Random random = new Random();
        CurrentNumber = random.nextInt(NumOfEmperor);
        return emperoror.get(CurrentNumber);

    }
    public static  String say(){
        return nameList.get(CurrentNumber);
    }
}