当前位置： 移动技术网 > IT编程>软件设计>设计模式 > 创建型模式：单例模式

创建型模式：单例模式

2019年01月15日  | 移动技术网IT编程  | 我要评论

个人博客原文：

月

简介

姓名：单例模式

英文名：singleton pattern

价值观：我的生活我主宰（只允许自己实例化，不愿意被其他对象实例化）

个人介绍：

ensure a class has only one instance, and provide a global point of access to it.（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）
(来自《设计模式之禅》)

这里的关注点有 3 个，分别是：

  1. 只有一个实例
  2. 自行实例化（也就是主动实例化）
  3. 向整个系统提供这个实例

你要的故事

我们脑洞大开来用一个故事讲解一番。

小明家里有一辆小汽车，具体什么牌子就不知道了，咱也不关注，反正他家里就这么一辆车，小明比较懒，只要一出门都会开车，例如去旅游、去学校、去聚会都会开车去。下面模拟小明出去的场景。

class car {
    public void run() {
        system.out.println("走。。。。");
    }
}


class xiaoming {
    public car travel() {
        system.out.println("小明去旅游");
        car car = new car();
        car.run();
        return car;
    }

    public car gotoschool() {
        system.out.println("小明去学校");
        car car = new car();
        car.run();
        return car;
    }

    public car gettogether() {
        system.out.println("小明参加聚会");
        car car = new car();
        car.run();
        return car;
    }
}

public class singletonerrortest {

    public static void main(string[] args) {
        xiaoming xiaoming = new xiaoming();
        car car1 = xiaoming.travel();
        car car2 = xiaoming.gotoschool();
        car car3 = xiaoming.gettogether();
    }

}

上面小汽车只有一个方法，就是走。小明去旅游、去学校、参加聚会都开着他唯一的一辆汽车车去。是不是有人有疑问？为什么每个方法都返回 car 对象？其实只是想在下面做一次检查，检查小明去旅游、去学校和参加聚会的车是不是同一辆。下面是检查代码：

system.out.println("car1 == car2 ? " + (car1 == car2));
system.out.println("car2 == car3 ? " + (car2 == car3));

最终结果是啥？很明显是 2 个 false。小明去旅游、去学校和参加聚会的车都不相同，小明不是只有 1 辆车？关键在于 car car = new car(); 这一句代码，其实这一句是创建一辆车，每次都重新创建一辆。那应该怎么实现小明只有一辆车呢？这时候就引入了单例模式。

上面我们说到了单例模式需要具备的 3 个点：只有 1 个实例，很显然，上面的代码不止 1 个实例，而是有 3 个 car 实例；自行实例化，car 本身没有主动实例化，而是在小明需要用到的时候才实例化；向整个系统提供这个实例，因为 car 没有主动实例化，所以它没法向外部暴露提供自己出来。

我们的代码完全不符合单例模式的要求。我们要通过修改，使之符合单例模式的 3 个要点。首先需要实现的是第 2 点，把 car 实例化从小明转为 car 本身，如下代码

class car1{

    private static car1 car1 = new car1();

    private car1() {

    }

    public void run(){
        system.out.println("走。。。。");
    }
}

上面代码使用 private 修饰构造方法，使得 car1 不能被其他使用方实例化，通过 car1 car1 = new car1(); 主动实例化自己。

接下来再实现第 3 点，向整个系统暴露这个实例，也就是暴露它自己。每个使用方都调用 car1.getinstance() 方法来获取实例。

class car1{

    private static car1 car1 = new car1();

    public static car1 getinstance() {
        return car1;
    }
    
    private car1() {

    }

    public void run(){
        system.out.println("走。。。。");
    }
}

上面代码就实现了单例模式的 2 和 3 要点，第 1 要点要怎么实现呢？告诉你，不用实现，只要满足了 2 和 3 要点就可以，第 1 要点是用来检验是否是单例模式的好思路。我们检验一下

class car1{

    private static car1 car1 = new car1();

    public static car1 getinstance() {
        return car1;
    }

    private car1() {

    }

    public void run(){
        system.out.println("走。。。。");
    }
}

class xiaoming1 {
    public car1 travel() {
        system.out.println("小明去旅游");
        car1 car = car1.getinstance();
        car.run();
        return car;
    }

    public car1 gotoschool() {
        system.out.println("小明去学校");
        car1 car = car1.getinstance();
        car.run();
        return car;
    }

    public car1 gettogether() {
        system.out.println("小明参加聚会");
        car1 car = car1.getinstance();
        car.run();
        return car;
    }
}

public class singletonrighthungrytest {

    public static void main(string[] args) {
        xiaoming1 xiaoming1 = new xiaoming1();
        car1 car1 = xiaoming1.travel();
        car1 car2 = xiaoming1.gotoschool();
        car1 car3 = xiaoming1.gettogether();

        system.out.println("car1 == car2 ? " + (car1 == car2));
        system.out.println("car2 == car3 ? " + (car2 == car3));
    }

}

上面代码最后两行打印出来的结果是啥？是我们想要的：2 个 true。说明小明这几次外出开的车都是同一辆。这是最简单的单例模式的实现方式，我们经常称作饿汉式单例模式。为什么起这么古怪的名字呢？其实和对应的懒汉式单例模式有关，这是 2 个实现方式的差别，饿汉式单例模式实现方式在类加载到内存的时候，就创建好对象了，而懒汉式则是在第一次使用的时候才创建对象，也就是把创建对象的时机从加载延迟到第一次使用，所以才有懒饿之分。

下面我们来看怎么实现懒汉式单例模式。先描述一下场景：小明还没有汽车，他也不知道什么时候要买汽车，突然某一天，他想去旅游，觉得是时候买辆车了，然后他就买车去旅游了，旅游回来又开车去学校和参加聚会。

class car2{

    private static car2 car2;

    public static synchronized car2 getinstance() {
        if (null == car2) {
            system.out.println("买车啦。。。");
            car2 = new car2();
        }
        return car2;
    }

    private car2() {

    }

    public void run(){
        system.out.println("走。。。。");
    }
}

class xiaoming2
{
    public car2 travel() {
        system.out.println("小明去旅游");
        car2 car = car2.getinstance();
        car.run();
        return car;
    }

    public car2 gotoschool() {
        system.out.println("小明去学校");
        car2 car = car2.getinstance();
        car.run();
        return car;
    }

    public car2 gettogether() {
        system.out.println("小明参加聚会");
        car2 car = car2.getinstance();
        car.run();
        return car;
    }
}

public class singletonrightlazytest {

    public static void main(string[] args) {
        xiaoming2 xiaoming2 = new xiaoming2();
        car2 car1 = xiaoming2.travel();
        car2 car2 = xiaoming2.gotoschool();
        car2 car3 = xiaoming2.gettogether();

        system.out.println("car1 == car2 ? " + (car1 == car2));
        system.out.println("car2 == car3 ? " + (car2 == car3));
    }

}

小明去旅游
买车啦。。。
走。。。。
小明去学校
走。。。。
小明参加聚会
走。。。。
car1 == car2 ? true
car2 == car3 ? true

上面附带了打印出来的结果，小明要去旅游的时候，才去买车。这就是懒汉式单例模式的实现方式。

要注意懒汉式单例模式有个很关键的一点就是 getinstance() 方法带上了 synchronized，这个是为什么呢？

首先得了解关键字 synchronized 的作用是什么：用于修饰执行方法同步，也就是说多线程并发的情况下，在一个时间点，只允许一个线程执行这个方法。

不加上这个会有什么结果？在多线程并发情况下，如果有 2 个线程同时执行到 if(null == car2)，那么都判断为 true，这时 2 个线程都会执行 car2 = new car2()，这样子就不是单例了。

总结

单例模式可以说是设计模式中最简单的一个，也是在工作中很多场景下经常用到的，比如：项目的配置文件加载、各种工具类等等。我们对于单例模式最重要的一点就是要考虑多线程并发，没有考虑这点就容易引发单例对象不单例的情况。而单例给我们带来最大的好处就是节约内存。

上面实现的两种方法是单例模式中最最最简单的 2 种实现，相信也是用得最多的实现方式。网上有不少网友分享了单例模式的很多种实现方法，大家也可以去了解，在了解之前务必已经搞懂文中这 2 种最简单的实现方式，不然会头晕的。

参考资料：《大话设计模式》、《java设计模式》、《设计模式之禅》、《研磨设计模式》、《head first 设计模式》

希望文章对您有所帮助，设计模式系列会持续更新，感兴趣的同学可以关注公众号，第一时间获取文章推送阅读，也可以一起交流，交个朋友。

公众号之设计模式系列文章

公众号

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网