四 单例模式

单例模式

定义

单例模式是一种对象创建型模式。使用单例模式，可以保证一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。

意义

提供对同一种资源的共享，节省创建对象的资源，提高效率。

为了只能创建一个类的实例，可以将类的构造函数私有化，并提供公共的接口，对类实例对象进行访问。

单列模式有分为懒汉式和饿汉式。

1、懒汉式

在类初始化时，便创建对象

代码如下：

public class Person {
    private static final Person person = new Person();
    private String name;


    public String getName() {
        return name;
    }

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

    //构造函数私有化
    private Person() {
    }

    //提供一个全局的静态方法
    public static Person getPerson() {
        return person;
    }
}

2、恶汉式

只有在需要类实例时，才进行创建

代码如下：

public class Person2 {
    private String name;
    private static Person2 person;

    public String getName() {
        return name;
    }

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

    //构造函数私有化
    private Person2() {
    }

    //提供一个全局的静态方法
    public static Person2 getPerson() {
        if(person == null) {
            person = new Person2();
        }
        return person;
    }
}

多线程中的处理

在单线程中，上面两种方式是没有问题的，但是在多线程中，可以看到懒汉式是没有问题的，而恶汉式是多线程不安全的。

那么该如何改进恶汉式在多线程中的应用呢，最简单的情况，便是同步，代码如下：

处理一

public class Person3 {
    private String name;
    private static Person3 person;

    public String getName() {
        return name;
    }

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

    //构造函数私有化
    private Person3() {
    }

    //提供一个全局的静态方法，使用同步方法
    public static synchronized Person3 getPerson() {
        if(person == null) {
            person = new Person3();
        }
        return person;
    }
}

可以看到，我们得到了想要的结果，但是仔细观察，发现处理一中的方法，会造成资源的浪费。例如：当线程1访问到getPerson()函数时，那么其他的线程就会一直等待。特别是当实例已经创建成功，但是，每次进行if(person == null) 的判断，也会进行同步，造成效率极低。

为了改进处理一中的方法，可以考虑只对创建实例的方法进行同步，如下：

处理二

public class Person4 {
    private String name;
    private static Person4 person;

    public String getName() {
        return name;
    }

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

    //构造函数私有化
    private Person4() {
    }

    //提供一个全局的静态方法
    public static Person4 getPerson() {
        if(person == null) {
            synchronized (Person4.class) {
                person = new Person4();
            }

        }
        return person;
    }
}

仔细观察，处理二中的方法是多线程不安全的。例如：线程1访问到synchronized (Person4.class) 时，线程2也刚好访问到此处。那么最终的结果便是，线程1创建了一个实例，线程2也创建了一个实例。

那么，可以进步改进，如下：

处理三

public class Person5 {
    private String name;
    private static Person5 person;

    public String getName() {
        return name;
    }

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

    //构造函数私有化
    private Person5() {
    }

    //提供一个全局的静态方法
    public static Person5 getPerson() {
        if(person == null) {
            synchronized (Person5.class) {
                if(person == null) {
                    person = new Person5();
                }
            }

        }
        return person;
    }
}