设计模式 | 单例模式（singleton）

路人甲Java 2020-07-04

展开全文

定义：

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

结构：（书中图，侵删）

结构超简单。就在你想控制实例数的类上操作即可。

1.定义一个static的对象引用

2.私有化构造方法

3.提供一个获取实例的方法（static的）

实例：

这又是一个在面试中频繁出现的设计模式，我至今不知道为什么大家那么偏爱这个模式。

而且基本上都是让你现场写一个单例模式的例子，基于这个很现实的原因，这个模式也好好好掌握。

我这里就不举生活中的例子了，直接上代码。

单例模式又分为两种形式：

一、饿汉式：在类加载是就初始化实例。

二、懒汉式：在第一次调用的时候，才初始化实例。

饿汉式：

package designpattern.singleton;public class HungrySingleton {private static HungrySingleton instance = new HungrySingleton();// 静态初始化private HungrySingleton() {// 私有化构造方法    }public static HungrySingleton GetInstance() {// 获取实例，static的return instance;
    }
}

懒汉式：

package designpattern.singleton;public class LazySingleton {private static LazySingleton instance;private LazySingleton() {// 私有化构造方法}public static LazySingleton getInstance() {// 获取实例，static的if (instance == null) {
            instance = new LazySingleton();// 方法中创造实例        }return instance;
    }
}

但是，如果是在多线程的情况下，可能会造成创造出两个实例的情况，可以考虑在getInstance方法上加上synchronized修饰：

package designpattern.singleton;public class LazySingleton2 {private static LazySingleton2 instance;private LazySingleton2() {

    }public static synchronized LazySingleton2 getInstance() {// synchronized 修饰if (instance == null) {
            instance = new LazySingleton2();
        }return instance;
    }
}

这个可以进一步优化，只让线程在还没有实例化的情况下加锁：

package designpattern.singleton;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class LazySingleton3 {private static LazySingleton3 instance;private static Lock lock = new ReentrantLock();private LazySingleton3() {

    }public static synchronized LazySingleton3 getInstance() {try {if (instance == null) {
                lock.lock();if (instance == null) {// 有必要再次判断，不然还是存在线程安全问题instance = new LazySingleton3();
                }
                lock.unlock();
            }
        } finally {// 保证锁被释放            lock.unlock();
        }return instance;
    }
}