期待你的分享

0%

单例模式

发表于 更新于 分类于

场景

(本例子来自于设计模式之禅)

中国历史悠久,从秦始皇开始了皇帝主宰整个国家,当然,同一个时代仅存在一个皇帝(后面会说一个特殊情况),大臣们都要听从皇帝发号施令,每天上朝向皇帝汇报任务,类比面向对象程序设计,相当于说是在当前运行环境下,仅存在某个类的一个实例,这个类就可以比作皇帝的位子,这个实例就是谁是皇帝,其他有调用这个类的方法或属性就相当于臣子向皇帝汇报,如何实现呢,关键之处就是只存在一个实例,实例的构造时机是在类初始化时发生的,那么就可以不让其他臣子类有构造皇帝类实例的权力即可,也就是构造方法私有化,那么如果私有化那怎样才能产生实例呢?我们其实可以构造一个当前类的静态对象,类型也是当前类,在其他臣子类想要汇报工作时返回这个对象即可,也就是下面这种情况: 
1
2
3
4
5
6
7
8
9
class Emperor{
    private static Emperor emperor = new Emperor();
    private Emperor(){
    
    }
    public static Emperor getEmperor() {
        return emperor;
    }
}

臣子可以这样调用它:

1
2
3
4
5
class Vassal{
    public void report(String msg){
        System.out.println(Emperor.getEmperor()+"皇帝"+msg);
    }
}

通过getEmperor()方法来得到唯一的皇帝实例即可,当然这种方式最好理解,只通过简单的实现来解决这个例子,接下来正式介绍单例模式

定义

确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例

实现

单例模式的实现有几种,上述的是最简单的,也叫做”饿汉式单例”,因为实例在调用前就已经存在了,下面介绍另外一种实现方式:

懒汉式(在调用时判断是否存在实例,不存在就创建一个):

1
2
3
4
5
6
7
8
9
10
11
12
13
// 在调用时根据对象状态来决定是否构造对象,非线程安全
class Sigleton1{
    private static Sigleton1 sigleton = null;
    private Sigleton1(){

    }
    public static Sigleton1 getInstance(){
        if (sigleton == null){
            sigleton = new Sigleton1();
        }
        return sigleton;
    }
}

这种是一般的思路,调用时判断对象是不是空,是的话new一个,不是的话直接返回即可,单线程下是没有问题的,多线程同步就会出现异常,比如还没有初始化时,A线程判断对象为空准备new,同时B线程也调用了get方法,也判断对象为空准备new,这时就会出现new了两次存在两个实例的情况,显然不符合我们期望的目标,那么我们就可以利用java的synchronized关键字来锁定对象或方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 线程安全,资源消耗较大
class Sigleton2{
    private static Sigleton2 sigleton = null;
    private Sigleton2(){

    }
    public static synchronized Sigleton2 getInstance(){
        if (sigleton == null){
            sigleton = new Sigleton2();
        }
        return sigleton;
    }
}
// 线程安全,相对前者资源消耗较小
class Sigleton3 {
    private static Sigleton3 sigleton = null;
    private Sigleton3(){

    }
    public static Sigleton3 getInstance(){
        if (sigleton == null){
            synchronized (sigleton){
                if (sigleton == null){
                    sigleton = new Sigleton3();
                }

            }
        }
        return sigleton;
    }
}

这样实现以后确实不会存在多线程同步问题,但是两者相比,下面的get方法显然锁定所消耗的资源更小,一个是方法级别,一个是对象级别,所以下面的更推荐使用,当然了也许会有疑问,有没有不同步也可以解决这个问题的呢,其实是有的,可以采用内部类调用的方式实现:

1
2
3
4
5
6
7
8
9
10
11
12
// 线程安全,且资源消耗较小
class Sigleton4 {
    private static class BetterSigleton{
        private static final Sigleton4 sigleton = new Sigleton4();
    }
    private Sigleton4(){

    }
    public Sigleton4 getInstance(){
        return BetterSigleton.sigleton;
    }
}

这种方法下,内部类已经存储了类的静态实例,get方法只需要返回内部类的静态对象即可,而内部类的初始化是在get方法时才会进行,所以也属于”懒汉式”

两种方式比较

  • 饿汉式: 在获取实例之前已经初始化了,资源占用刚开始高一些,因为要一直维护这个实例,且线程安全
  • 懒汉式: 在获取实例时才去初始化对象,在获取实例时消耗一些资源,因为只在这时才会初始化,线程安全方面分情况,上面说的第1种非线程安全,2,3,4都是线程安全的

感悟

单例模式用的比较明显的地方就是spring的bean配置与管理了,对于一个类配置好了一个bean,在其他类用到的时候就把这个类的实例拿给它用就可以了,然后关于懒汉式的几种方式的应用场景,和相互的更深的比较还有待思考,有时间再学习