设计模式之创建型模式

最新推荐文章于 2024-10-06 09:53:07 发布

_SnowMultiflora

最新推荐文章于 2024-10-06 09:53:07 发布

阅读量130

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/Xw_Vivian/article/details/102941903

版权

设计模式专栏收录该内容

3 篇文章 0 订阅

订阅专栏

设计模式可分为三种：创建型模式、结构型模式和行为型模式

创建型模式是什么？

简单来说就是帮我们创建对象的

创建模式又有：单例模式、工厂模式、建造者模式和原型模式

单例模式

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

优点：– 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决；

– 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

实现单例模式的5种方式：

饿汉式：线程安全，调用效率高，不能延时加载

（ps:饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！）

package com.zxw.singleton;

/**
 * 测试饿汉式单例模式
 */
public class SingletonDemo1 {
	
	//类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
	private static SingletonDemo1 instance = new SingletonDemo1();  
	
	private SingletonDemo1(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo1  getInstance(){
		return instance;
	}
	
}

懒汉式：线程安全，调用效率低（因为方法同步），能延时加载

(ps:问题资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低。 )

package com.zxw.singleton;

/**
 * 测试懒汉式单例模式
 */
public class SingletonDemo2 {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo2 instance;  
	
	private SingletonDemo2(){ //私有化构造器
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo2  getInstance(){
		if(instance==null){
			instance = new SingletonDemo2();
		}
		return instance;
	}
	
}

双重检测锁式：线程安全，调用效率高（只是比懒汉式好），能延时加载，由于JVM底层内部模型原因，偶尔会出问题。不建议使用

package com.zxw.singleton;

/**
 * 双重检查锁实现单例模式(不推荐使用)
 */
public class SingletonDemo3 {

    private static SingletonDemo3 instance = null;

    public static SingletonDemo3 getInstance() {
        if (instance == null) {
            SingletonDemo3 sc;
            synchronized (SingletonDemo3.class) {
                sc = instance;
                if (sc == null) {
                    synchronized (SingletonDemo3.class) {
                        if (sc == null) {
                            sc = new SingletonDemo3();
                        }
                    }
                    instance = sc;
                }
            }
        }
        return instance;
    }

    private SingletonDemo3() {

    }

}

静态内部类式：线程安全，调用效率高，能延时加载

(外部类没有static属性，则不会像饿汉式那样立即加载对象.只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。 instance是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。兼备了并发高效调用和延迟加载的优势！)

package com.zxw.singleton;

/**
 * - 外部类没有static属性，则不会像饿汉式那样立即加载对象。
 * – 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。
 *   instance是static final 类型
 *   保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
 * – 兼备了并发高效调用和延迟加载的优势！
 *
 *  * 测试静态内部类实现单例模式
 *  * 这种方式：线程安全，调用效率高，并且实现了延时加载！
 */
public class SingletonDemo4 {
    //静态内部类
    private static class SingletonClassInstance{
        private static final SingletonDemo4 instance=new SingletonDemo4();
    }

    public static SingletonDemo4 getInstance(){
        return SingletonClassInstance.instance;
    }

    private SingletonDemo4(){

    }

}

枚举单例：线程安全，调用效率高，不能延时加载

（可以避免通过反射和反序列的方式破坏单例）

package com.zxw.singleton;

/**
 * 线程安全，调用效率高，不能延时加载
 */
public enum  SingletonDemo5 {
    //定义一个枚举元素 代表一个单例
     INSTANCE;
     //单例可以有自己的操作
     public void singletonOperation(){
         //功能处理
     }

}

除了枚举方式，其他方式可以通过反射和反序列化来破坏单例，我们可以这样做：

package com.zxw.singleton;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
 *
 */
public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	
	private SingletonDemo6(){ //私有化构造器
		if(instance!=null){
			throw new RuntimeException();
		}
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}
	
	//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
	
}

所以这么多种方式，我们要怎么抉择呢？

如果单例对象占用资源少，且需要延时，静态内部类方式比懒汉式要好；

如果单例对象占用资源大，且不需要延时，枚举方式比饿汉式要好。