单例模式

####示例代码 皇帝类：

public class Emperor{
    private static final Emperor emperor = new Emperor();//初始化一个实例
    private Emperor(){
        //只能产生一个实例
        }
    public static Emperor getInstance(){
        return emperor ;
    }
    public static void say(){
        System.out.println("朕是某帝王");
    }
}

臣子访问类：

public class Minister{
    public static void main(String[] args){
        for(int day = 0;day <3;day++){      //三天面见同一皇帝实例
            Emperor emperor = Emperor.getInstance();
            emperor.say();
        }
    }
}

单例模式定义

单利模式（Singleton pattern）：Ensure a class has only one instance, and provide a global point of access to it.

单例模式通用代码（饿汉式单例）

public class Singleton{
    private static final Singleton singleton = new Singleton();
    //限制产生多个对象
    private Singleton(){        
    }
    //通过该方法获得实例对像
    public static Singleton getSingleton(){
        return singleton;
    }
    //类中其他方法，尽量是static
    public staitc void doSomething(){
        
    }
}

单例模式的使用场景：

• 要求生成唯一的序列号的环境
• 有共同的访问点
• 创建一个对象需要消耗的资源过多
• 需要定义大量的静态常量和静态方法

懒汉式单例(线程不安全)：

public class Singleton{
    private static Singleton singleton = null;
    //限制产生多个对象
    private Singleton(){
        
    }
//通过该方法获得实例对象
    public static Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
            return singleton;
    }
}

解决线程不安全方法：

• 可以在getSingleton方法前加synchronized关键字，也可以在getSingleton方法内增加synchronized来实现
• 使用饿汉式单例

其次，要考虑对象克隆情况，单例类不要实现Cloneable接口就不存在克隆情况。因为java类只有实现Cloneable接口并实现clone方法才可以克隆。

单例模式的扩展：（产生固定数量的对象）

public class Emperor{
    //定义最多能产生的实例数量
    private static int maxNumOfEmperor = 2;
    //每个皇帝都有名字，使用一个ArrayList来容纳，每个对象的私有属性
    private static ArrayList<String>  nameList = new ArrayList<String>();
    //定义一个列表，容纳所有皇帝
    private static ArrayList<Emperor> emperorList = new ArrayList<Emperor>();
    //当前皇帝序列号
    private static int countNumOfEmperor = 0;

    //产生所有的对象
    static{
          for(int i = 0; i<maxNumOfEmperor;i++){
            emperorList.add(new Emperor("皇帝"+(i+1)+"帝"));
        }
    }
    private Emperor(){
    
    }
    //传入皇帝名称，建立一个皇帝对象
    private Emperor(String name){
        nameList.add(name)
    }
    //随机获得一个皇帝对象
    public static Emperor getInstance(){
        Random random = new Random();
        //随机拉出一个皇帝，只要是精神领袖就成
         countNumOfEmperor = random.nextInt(maxNumOfEmperor);
        return emperorList.get(countNumOfEmperor);          
    }
    public static void say(){
        System.out.println(nameList.get(countNumberOfEmperor));
    }
}

臣子访问类：

public class Minister{
    pbucli static void main(String[] args){
        //定义5个大臣
        int ministerNum = 5;
        for(int i = 0;i<ministerNum;i++){
            Emperor emperor = Emperor.getInstance();
            System.out.print("第"+(i+1)+"个大臣参拜的是：");
            emperor.say();
        }
    }
}

应用实践

Spring中每个Bean默认都是单例的，其优点Spring 容器可以管理Bean的生命周期。

转载于:https://my.oschina.net/u/3230371/blog/1526212