设计模式(4)之单例模式

最新推荐文章于 2024-09-16 17:08:47 发布

King.W.

最新推荐文章于 2024-09-16 17:08:47 发布

阅读量488

点赞数

分类专栏：设计模式文章标签：计算器工厂模式单例模式

本文链接：https://blog.csdn.net/birdflyto206/article/details/51170500

版权

设计模式专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1. 什么是单例模式
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。其实，GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

2. 为什么要使用单例模式呢？
在应用系统开发中，我们常常有以下需求：
- 在多个线程之间，比如servlet环境，共享同一个资源或者操作同一个对象
- 在整个程序空间使用全局变量，共享资源
- 大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。

因为Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模式就派上用场了。

3. 单例模式实现
1.饿汉式。
2.懒汉式。
3.双重检查。

//Perosn.java

//一般的类
public class Person {

    private String name;

    public String getName() {
        return name;
    }

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

}

使用的时候，直接new。

//MainClass.java

public class MainClass {

    public static void main(String[] args) {

        Person person1 = new Person();
        Person person2 = new Person();

        person1.setName("zhangsan");
        person2.setName("lisi");

        System.out.println(person1.getName());
        System.out.println(person2.getName());
    }
}

显然，person1和person2是两个不同的对象，打印的结果肯定不同。所以，要想实单例模式，需要对Person类进行改造。

下面介绍【饿汉式】实现单例模式。

//Person2.java 

//饿汉式实现

public class Person2 {
    // 饿汉式的特点，不管三七二十一，类加载的时候就new一个对象出来，这个对象是全局的，整个应用程序中只有一份。在类加载的时候就new出来。
    private static final Person2 person = new Person2();
    //首先，将构造方法写成私有的，这样在外部就不能new了。
    private Person2(){}

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //对外提供一个方法访问这个全局唯一的一个实例对象。
    public static Person2 getPerson2(){
        return person;
    }
}

下面是【懒汉式】实现单例模式：


public class Person3 {

    private static Person3 person = null;

    private Person3(){}

    private String name;

    public String getName() {
        return name;
    }

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

    public static **synchronized** Person3 getPerson3(){
        //在获取该类实例之前，如果之前没有new这个实例，则new一个。如果有了这个实例，直接返回之前的那个实例对象。
        //这种在用到的时候才new对象方式就叫做【懒汉式】。
        if(person == null)
            person  = new Person3();

        return person;
    }

}

好了，到这里，是时候说一个问题了。大家有没有注意到，在懒汉式实现方法中，加了一个synchronized关键字，这是线程同步用的。
这里写图片描述
（1）如果没有synchronized关键字
在多线程程序中，如果线程1和2同时进入到getPerson3方法中，又如果线程1执行完if(person==null)之后，此时CPU的执行权切回到线程2，线程2也进入getPerson3方法，执行了if(person==null)，因为此时并没有Person3的实例，所以线程1和2都会进如到if语句块中，这样就会导致new了两次Person3，这样肯定不是单利模式啦。
（2）如果加了synchronized关键字
这里写图片描述
如果加了synchronized关键字，那么当线程1访问getPerson3方法的时候，即使CPU执行权被切换到其他线程上，其他线程也不能够访问getPerson3方法，因为该方法当前正在被线程1访问，除非线程1执行完了该方法并退出之后，其他线程才能访问该方法。然而此时已经创建了一个Person3的实例了，person变量不为null，所以尽管其他方法进入getPerson3方法，判断条件不成立，也就不会再创建Person3对象了。这就保证了单例。

但是，大家有没有考虑一个问题，你线程1在访问的时候，其他的线程如果访问该方法都得在外面等着，凭啥呀？这不耽误大家的时间吗，是不是。显然这种方法是不高效的。

我们仔细观察下getPerson3这个方法，这个方法是不是只有一行代码需要同步，就是new Person3这行代码，其他的代码是不需要同步的。所以说呀，为了这行代码，就让整个方法同步，这个不太好吧，如果方法中还有其他一大坨的代码不需要同步呢，你把其他线程拒之门外是不是太耽误事儿了。所以，我们可以使用同步局部代码块的方法解决这个问题。
这里写图片描述
现在我们来分析一下，如果两个线程同时进入到getPerson3方法中，并且都进入到if语句块中，会不会new出两个Person对象呢？不会的。仔细看看代码，当线程1 new了Person之后，person变量就不为null，此时线程2进入同步代码块后，再new之前又进行了一次person是否为null的判断，显然person是不为null，所以肯定不会new一个新的Person，这也保证了单例。这就是第三种实现单例的方式–【双重检查】。