【JavaEE】单例模式（饿汉&懒汉）

目录

前言：

单线程下的单例模式

饿汉模式

懒汉模式

多线程下的单例模式

懒汉模式的修改

1.加锁

2.有条件的加锁

3.解决内存可见性和指令重排序

---

前言：

本片文章介绍设计模式中的一个模式——单例模式。

单例模式就是只允许创建出一个实例的类。比如之前在使用JDBC编程的时候的DataSource这个类，就可以使用单例模式。见这篇文章http://t.csdn.cn/uq1lR。

其中单例模式有很多种实现方法，这里只用懒汉模式和饿汉模式来实现单例模式。

---

单线程下的单例模式

单线程中，没有线程安全问题，其代码会简单很多。

饿汉模式

饿汉模式体现出一个字——急。因为这个实例直接就是在类加载阶段就被创建出来。

class SingletonHungry{

    // 用static修饰，这样在类加载阶段就有了这个实例
    private static SingletonHungry instance = new SingletonHungry();

    // 用静态公开方法返回实例
    public static SingletonHungry getInstance() {
        return instance;
    }

    // 为了防止实例化多个对象，把构造方法用private修饰
    private SingletonHungry(){};

}

public class SingletonTest1 {

    public static void main(String[] args) {

        SingletonHungry instance1 = SingletonHungry.getInstance();
        SingletonHungry instance2 = SingletonHungry.getInstance();
        System.out.println(instance1 == instance2);

        //SingletonHungry instance3 = new SingletonHungry();

    }

}

 

 

---

懒汉模式

懒汉模式突出一个字——懒。这个实例是只有调用获取实例方法的时候才创建出来。

class SingletonLazy{
    private static SingletonLazy instance = null;

    // 只有在调用了该方法后才创造出了实例
    public static SingletonLazy getInstance() {
        // 如果已经创建了该实例，就直接返回之前的实例
        if (instance == null) {
            instance =  new SingletonLazy();
        }
        return instance;
    }

    // 为了防止实例化多个对象，把构造方法用private修饰
    private SingletonLazy(){}
}

public class SingletonTest2 {

    public static void main(String[] args) {

        SingletonLazy instance1 = SingletonLazy.getInstance();
        SingletonLazy instance2 = SingletonLazy.getInstance();
        System.out.println(instance1 == instance2);

        //SingletonLazy instance3 = new SingletonLazy();
    }

}

代码结果如上。 

---

多线程下的单例模式

在上述代码中，如果考虑多线程的话

饿汉模式没有线程安全问题，它直接就是在类加载是创建出了一个实例，使用该实例也没有其他修改的操作，直接返回即可。

懒汉模式是有线程安全问题。它又要判断比较实例是否为null，又要创建一个实例，最后才返回实例。其中对于实例是由修改的操作的。只要有修改操作，就可能会有线程安全问题。如下图：

懒汉模式的修改

1.加锁

对于这种又有读，又有写的操作，保持原子性——加锁即可。

    public SingletonThread getInstance() {
        // 这里对于load cmp new这几步加锁，保持了其原子性
        synchronized (SingletonThread.class) {
            if (instance == null) {
                instance = new SingletonThread();
            }
        }
        return instance;
    }

2.有条件的加锁

但是加锁是一种开销比较大的操作，上述加锁操作并不是每次都要加锁的。如果已经创建了实例，直接返回实例即可。

    public SingletonThread getInstance() {
        // 如果实例未被创建，用加锁的方法创建实例
        // 如果创建，直接返回
        if (instance == null) {
            // 这里对于load cmp new这几步加锁，保持了其原子性
            synchronized (SingletonThread.class) {
                if (instance == null) {
                    instance = new SingletonThread();
                }
            }
        }
        return instance;
    }

3.解决内存可见性和指令重排序

内存可见性：因为instance要读取并修改，所以对于内存可见性的问题也要预防。

指令重排序：

上面的new实例的指令又分为三个顺序步骤：

①申请内存空间

②调用构造方法，实例化一个对象

③把内存空间的地址赋值给这个对象

这几步可能可能会变成①③②。单线程下没有问题，但是多线程就会有问题了。

要想解决这两个问题，使用volatile关键字修饰instance即可。

    private volatile static SingletonThread instance = null;

完整的懒汉模式的线程安全代码如下：

// 修改懒汉模式，使其线程安全
class SingletonThread {
    // 使用volatile解决内存可见性和指令重排序问题
    private volatile static SingletonThread instance = null;

    public SingletonThread getInstance() {
        // 如果实例未被创建，用加锁的方法创建实例
        // 如果创建，直接返回
        if (instance == null) {
            // 这里对于load cmp new这几步加锁，保持了其原子性
            synchronized (SingletonThread.class) {
                if (instance == null) {
                    instance = new SingletonThread();
                }
            }
        }
        return instance;
    }

}

---

有什么问题评论区指出。希望可以帮到你。