单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一,也是一种很常见的设计模式。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
下面我们来一张比较有意思的图说明:
这样单例模式保证一个类只有一个实例,减少了内存开销,尤其是那种频繁的创建和摧毁的场景,避免了对资源的多重占用,比如文件IO操作。
1、在内存里只有一个实例,减少了内存开销,尤其是那种频繁的创建和摧毁的场景。
2、避免对资源的多重占用,比如文件操作。
1、没有接口,不能被继承,违背了单一职责设计原则,一个类应该只关心其内部业务逻辑,而不关心外部怎么实例化。
2、 该模式在多线程环境下需要进行特殊处理, 避免多个线程多次创建单例对象。
3、单例的客户端代码单元测试可能会比较困难, 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的, 而且绝大部分语言无法重写静态方法, 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码, 或者不使用单例模式。
首先创建单例模式类,私有化构造方法,一来就创建一个单例对象,表示很饥饿。
/**
* @description: 单列模式
* @author: dt
* @date: 2021/4/5 12:16
* @version: v1.0
*/
public class Hungry {
/**
* 让构造函数为 private,这样该类就不会被实例化
*/
private Hungry() {
}
/**
* 创造一个静态单例对象
*/
private final static Hungry HUNGRY = new Hungry();
/**
* 获取唯一可用的对象
* @return
*/
public static Hungry getInstance(){
return HUNGRY;
}
public void showMessage(){
System.out.println("Hello World!");
}
}
获取单例对象实例:
public static void main(String[] args) {
// 不可用被实例化,编译直接报错
// Hungry hungry = new Hungry();
// 获取唯一可用对象
Hungry hungry = Hungry.getInstance();
hungry.showMessage();
}
但是这样的饿汉式模式是有问题的,会产生什么问题呢?
假设这里有四组资源,是非常耗内存的,浪费空间,我们应该在使用的时候再去加载,于是乎就有了懒汉式单列模式。
/**
* @description: 单列模式
* @author: dt
* @date: 2021/4/5 12:16
* @version: v1.0
*/
public class Hungry {
/**
* 假设这里有四组资源,是非常耗内存的,浪费空间,我们应该在使用的时候再去加载
*/
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
/**
* 让构造函数为 private,这样该类就不会被实例化
*/
private Hungry() {
}
/**
* 创造一个单例对象
*/
private final static Hungry HUNGRY = new Hungry();
/**
* 获取唯一可用的对象
* @return
*/
public static Hungry getInstance(){
return HUNGRY;
}
public void showMessage(){
System.out.println("Hello World!");
}
}
/**
* @description: 懒汉式单列模式
* @author: ydf
* @date: 2021/4/12 21:47
* @version: v1.0
*/
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName());
}
public static LazyMan lazyMan;
public static LazyMan getInstance(){
// 不为null,我们才使用实例对象
if(lazyMan==null){
lazyMan = new LazyMan();
}
return lazyMan;
}
// 单线程下单列模式可以运行的,完全没问题,如果并发条件下就有问题了
// 测试并发条件
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
打印结果:
单线程下单列模式可以运行的,完全没问题,如果并发条件下就有问题了。那么怎么解决呢?
加锁控制:双重检测锁模式
/**
* @description: 懒汉式单列模式
* @author: ydf
* @date: 2021/4/12 21:47
* @version: v1.0
*/
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName());
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance(){
// 加锁,双重检测一下
if(lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan == null){
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
// 单线程下单列市客运的,如果并发条件下就有问题了
// 测试并发条件
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
通过观察我们可以看到通过双重检测锁,保证了线程对象的唯一,测试成功。
1、执行效率上:饿汉式没有加任何的锁,因此执行效率比较高。懒汉式一般使用都会加同步锁,效率比饿汉式差。
2、性能上:饿汉式在类加载的时候就初始化,不管你是否使用,它都实例化了,所以会占据空间,浪费内存。懒汉式什么时候需要什么时候实例化,相对来说不浪费内存。
3、饿汉式: 在类加载时就初始化创建单例对象,线程安全,但不管是否使用都创建对象可能会浪费内存。
4、懒汉式: 在外部调用时才会加载,线程不安全,可以加锁保证线程安全但效率低。