单例模式介绍

最新推荐文章于 2024-09-27 16:57:18 发布
最新推荐文章于 2024-09-27 16:57:18 发布
阅读量148 收藏
点赞数
分类专栏： 设计模式 文章标签： 单例模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16116881/article/details/121876782
版权

文章目录

1、单例介绍
1.1、单例模式使用场景

单例模式(Singleton Pattern )是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛。J2EE标准中的ServletContext ,ServletContextConfig 等、 Spring 框架应用中ApplicationContext、数据库的连接池等也都是单例形式。

1.2、单例的实现思路
  • 静态化实例对象。
  • 私有化构造方法，禁止通过构造方法创建实例。
  • 提供一个公共的静态方法，用来返回唯一实例。
2、饿汉式单例
2.1、特点

饿汉式单例在类加载的时候就初始化创建对象。线程安全，但是占用、浪费内存。

2.2、标准饿汉式单例代码
public class HungrySingleton {

    // 类初始化的时候就创建对象
    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return  hungrySingleton;
    }
}
2.3、静态代码块饿汉式单例

这种方式和直接使用静态属性的方式差异不大。可以说没有什么差异。只是利用静态代码块初始化对象。

public class HungryStaticSingleton {
    //先静态后动态
    //先上，后下
    //先属性后方法
    private static final HungryStaticSingleton hungrySingleton;

    static {
        hungrySingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton(){}

    public static HungryStaticSingleton getInstance(){
        return  hungrySingleton;
    }
}
3、懒汉式单例
3.1、特点

在单例对象被调用的时候才初始化，不浪费内存，但是存在线程安全的问题。

3.2、标准懒汉式

通过加synchronizedd 的方式解决线程安全问题，降低了效率。

public class LazySimpleSingletion {
    private static LazySimpleSingletion instance;
    private LazySimpleSingletion(){}

    public synchronized static LazySimpleSingletion getInstance(){
        if(instance == null){
            instance = new LazySimpleSingletion();
        }
        return instance;
    }
}
3.3、双重检查方式（double check）

在LazyDoubleCheckSingleton还没有创建的时候，如果存在多条线程调用getInstance()方法，就会出现并发的问题。所以这里两条线程都会走到synchronized同步代码块里面，这样再来一次判断，保证了LazyDoubleCheckSingleton只会被创建一次。

当LazyDoubleCheckSingleton创建以后，这时候不管有多少线程来访问getInstance()方法，通过第一次判断就获得LazyDoubleCheckSingleton对象，就不需要再获取锁，所以对比标准模式，提高了执行效率。

public class LazyDoubleCheckSingleton {
    // volatile 防止指令重排序的问题
    private volatile static LazyDoubleCheckSingleton instance;
    private LazyDoubleCheckSingleton(){}

    public static LazyDoubleCheckSingleton getInstance(){
        //检查是否要阻塞
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                //检查是否要重新创建实例
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

如果不明白为什么要加volatile关键字，戳这里

4、最牛单例

这个单例是基于懒汉式模式，通过静态内部类的特性(不会自动初始化。只有调用静态内部类的方法，静态域，或者构造方法的时候才会加载静态内部类)解决线程安全和内存浪费的问题。java类加载顺序

public class LazyStaticInnerClassSingleton {

    // 构造方法私有,只能通过统一入口获取对象
    private LazyStaticInnerClassSingleton(){
        // 这里防止通过反射强制访问创建对象
        if(LazyHolder.INSTANCE != null){
            throw new RuntimeException("不允许非法访问");
        }
    }

    // 提供唯一的访问入口,static修饰不会被重写
    private static LazyStaticInnerClassSingleton getInstance(){
        return LazyHolder.INSTANCE;
    }

    // 通过静态内部类的方式,实现再对象被调用到的时候才创建
    private static class LazyHolder{
        private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
    }
}
5、破坏单例的方法
5.1、反射破坏单例

通过反射的方式，强制访问构造方法，创建对象。

public static void main(String[] args) {
    try {
        Class<?> clazz = LazyStaticInnerClassSingleton.class;
        // 通过反射获取私有构造函数
        Constructor c = clazz.getDeclaredConstructor(null);
        // 强制访问
        c.setAccessible(true);
        // 暴力初始化
        Object instance1 = c.newInstance();
        // 再次暴力初始化
        Object instance2 = c.newInstance();
        System.out.println(instance1 == instance2); // false
    }catch (Exception e){
        e.printStackTrace();
    }
}

反射破坏单例的方式，可以通过最牛单例中的如下代码解决

// 构造方法私有,只能通过统一入口获取对象
private LazyStaticInnerClassSingleton(){
    // 这里防止通过反射强制访问创建对象
    if(LazyHolder.INSTANCE != null){
        throw new RuntimeException("不允许非法访问");
    }
}
5.2、序列化破坏单例

例如，可以通过如下代码来破坏单例

// 单例类
public class SerializableSingleton implements Serializable {

    public  final static SerializableSingleton INSTANCE = new SerializableSingleton();
    private SerializableSingleton(){}

    public static SerializableSingleton getInstance(){
        return INSTANCE;
    }
}


// 测试类
public class SerializableSingletonTest {
    public static void main(String[] args) {

        SerializableSingleton s1 = null;
        SerializableSingleton s2 = SerializableSingleton.getInstance();

        FileOutputStream fos = null;
        try {
			// 序列化
            fos = new FileOutputStream("SerializableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            // 反序列化
            FileInputStream fis = new FileInputStream("SerializableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SerializableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);
			/**
			 * 输出结果
             * com.gupaoedu.vip.pattern.singleton.seriable.SeriableSingleton@5fe5c6f
             * com.gupaoedu.vip.pattern.singleton.seriable.SeriableSingleton@5fe5c6f
             * false
             */
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

预防方法，可以通过添加readResolve()方法即可，如下代码测试

// 单例类
public class SerializableSingleton implements Serializable {

    public  final static SerializableSingleton INSTANCE = new SerializableSingleton();
    private SerializableSingleton(){}

    public static SerializableSingleton getInstance(){
        return INSTANCE;
    }
    
    // 添加此方法后，反序列化后的对象和序列化之前的对象是一个对象
    private Object readResolve(){ return INSTANCE;}
}


// 测试类
public class SerializableSingletonTest {
    public static void main(String[] args) {

        SerializableSingleton s1 = null;
        SerializableSingleton s2 = SerializableSingleton.getInstance();

        FileOutputStream fos = null;
        try {
			// 序列化
            fos = new FileOutputStream("SerializableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            // 反序列化
            FileInputStream fis = new FileInputStream("SerializableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SerializableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);
			/**
			 * 输出结果
             * com.gupaoedu.vip.pattern.singleton.seriable.SeriableSingleton@5fe5c6f
             * com.gupaoedu.vip.pattern.singleton.seriable.SeriableSingleton@5fe5c6f
             * true
             */
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这里通过添加readResolve()解决了单例的问题，但是单例还是实例化了两次，只是第二次返回的是第一次的地址。

6、注册式单例

注册式单例又称登记式单例，是把每个实例对象登记到某个地方，通过唯一标识获取实例。注册式单例模式有两种，一种枚举单例模式，另一种容器式单例模式。

6.1、枚举式单例模式

枚举单例的代码示例

public enum EnumSingleton {
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance(){return INSTANCE;}
}

我个人对枚举单例的使用理解不太透彻，如下单例改造成枚举单例的案例仅供参考：

// 正常单例
public class PoolWorker {

	private final static Logger log = LoggerFactory.getLogger(PoolWorker.class);

	// 构造函数私有
	private PoolWorker() {
		if(InitPoolWorker.poolWorkers != null){
			throw new RuntimeException("PoolWorker has been created!");
		}
	}

	// 唯一访问入口
	public static ExecutorService getPoolWorkers() {
		return InitPoolWorker.poolWorkers;
	}

	// 通过静态内部类的方式初始化，被调用的时候才初始化
	private static class InitPoolWorker{
		private static ExecutorService poolWorkers = new ThreadPoolExecutor(
				10,
				20,
				1000,
				TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<>(5),
				(Runnable r) -> {
					log.info("线程{}创建",r.hashCode());
					Thread th = new Thread(r,"threadPool"+r.hashCode());
					return th;
				},
				new ThreadPoolExecutor.CallerRunsPolicy());
	}

}

// 改造后枚举单例
public enum PoolWorker2 {
    INSTANCE;
    private final static Logger log = LoggerFactory.getLogger(PoolWorker.class);
    // 唯一访问入口
    public static ExecutorService getPoolWorkers() {
        return InitPoolWorker.poolWorkers;
    }

    // 通过静态内部类的方式初始化，被调用的时候才初始化
    private static class InitPoolWorker{
        private static ExecutorService poolWorkers = new ThreadPoolExecutor(
                10,
                20,
                1000,
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(5),
                (Runnable r) -> {
                    log.info("线程{}创建",r.hashCode());
                    Thread th = new Thread(r,"threadPool"+r.hashCode());
                    return th;
                },
                new ThreadPoolExecutor.CallerRunsPolicy());
    }
}

在我看来，单例枚举的使用，仅仅是通过枚举的特性，解决正常单例会出现的反射和序列化破坏单例的问题。但是，在使用的时候还是通过通过静态内部类单例或者double check 的方式来实现。

6.2、容器式单例模式

容器式单例模式，适用于需要创建大量单例对象的场景，便于管理。在spring的IOC中也使用到。

public class ContainerSingleton {

    private ContainerSingleton(){}

    private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>();

    public static synchronized Object getInstance(String className){
        Object instance = null;
        if(!ioc.containsKey(className)){
            try {
                instance = Class.forName(className).newInstance();
                ioc.put(className, instance);
            }catch (Exception e){
                e.printStackTrace();
            }
            return instance;
        }else{
            return ioc.get(className);
        }
    }
}
fanger8848
关注
专栏目录
三、单例模式详解
编程之心的博客
02-27 1152
4.单例模式详解 4.1.课程目标 1、掌握单例模式的应用场景。 2、掌握IDEA环境下的多线程调试方式。 3、掌握保证线程安全的单例模式策略。 4、掌握反射暴力攻击单例解决方案及原理分析。 5、序列化破坏单例的原理及解决方案。 6、掌握常见的单例模式写法。 4.2.内容定位 1、听说过单例模式，但不知道如何应用的人群。 2、单例模式是非常经典的高频面试题，希望通过面试单例彰显技术深度，顺利拿到...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
JAVA单例模式介绍及使用
低调D树苗的博客
03-16 822
单例模式是一种常见的设计模式，在JAVA中也有多种实现方式。无论使用哪种方式，单例模式的目的都是确保类只有一个实例，并提供全局访问点来访问该实例。我们可以根据实际需要选择合适的单例模式实现方式，并根据需要调整代码以提高性能和线程安全性。
单例模式介绍和使用
在下是小白的博客
03-17 1704
目录一、概念二、饿汉式1.静态变量2.静态代码块方式三、懒汉式方式一(线程不安全)方式二（线程安全）方式三（双重检查锁）方式四（静态内部类方式）四、枚举方式(恶汉式方式)五、存在的问题和解决方式1.序列化方式2.反射方式 一、概念 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例） 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯
Python单例模式介绍、使用
captain
07-21 1245
是Python中的一个装饰器（decorator），它表明该方法是一个静态方法。静态方法是一个与类相关的函数，不依赖于类中的任何实例，因此静态方法可以在不创建类的实例的情况下调用。静态方法可以在类中使用，也可以在类外部使用。静态方法使用装饰器来声明。在上面的代码中，我们定义了一个MyClass类，并使用装饰器来声明静态方法my_static_method()。请注意，与其他编程语言不同，Python中的静态方法可以访问类变量，但不能访问实例变量。是一个装饰器（decorator），用于声明一个静态方法。
C++ 单例模式
qwert55kai的博客
04-11 2400
c++单例模式
【C++】C++ 单例模式总结（5种单例实现方法）
unonoi的博客
11-04 9万+
C++ 单例模式的几种实现方式。
单例模式介绍，及其应用场景？
weixin_44416039的博客
05-24 307
单例模式(Singleton Pattern)是 Java中最简单的设计模式之一,此模式保证某个类在运行期间,只有一个实例对外提供服务，而这个类被称为单例类。单例模式也比较好理解，比如一个人一生当中只能有一个真实的身份证号，一个国家只有一个政府，类似的场景都是属于单例模式。使用单例模式要做的两件事。
单例模式介绍与使用
狗狗大蛇
04-18 751
目录 一、单例模式概念： 二、单例模式的组成套路(3个条件) 三：几种类型示例 四、本节总结 单例模式在java编程的过程中经常被使用到，比如日常开发中，数据库的连接池不会反复创建，及在spring框架中创建的bean默认都是单例的。 一、单例模式概念： 如果一个类只允许创建一个对象（实例），保证在一个 JVM 中只存在单一实例，那这个类就是一个单例类，这种设计模式就叫单例模式。 作用：主要解决一个全局的使用类被频繁地创建与销毁问题，，从而提升代码的整体性能； 种类：饿汉式、懒汉.
C++中的单例模式介绍
01-21
单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然...
PHP最常用的2种设计模式工厂模式和单例模式介绍
10-27
本篇文章将介绍PHP中最为常用的两种设计模式——工厂模式和单例模式。 首先，工厂模式的主要作用是降低系统各模块之间的耦合度。耦合度是指模块之间的依赖关系，耦合度越低，系统的模块越独立，越容易升级和维护。...
什么是单例模式？
weixin_44593575的博客
09-23 528
由于使用者在类外部不能使用构造函数，所以在类内部创建的这个唯一的对象必须是静态的，这样就可以通过类型来访问了，为了不破坏类的封装，我们都会把这个静态对象的访问权限设置为私有的。在一个项目中，全局范围内，某个类的实力有且仅有一个，通过这个唯一实例想其他模块提供数据的全局访问，这种模式就叫单例模式。饿汉模式下是没有线程安全问题的，因为在这种模式下访问单例对象的时候，这个对象已经被创建出来了。懒汉模式是在类加载的时候不去创建这个唯一的实例，而是需要使用的时候再进行实例化。拷贝赋值操作符重载函数私有化或者禁用。
【unity进阶知识1】最详细的单例模式的设计和应用，继承和不继承MonoBehaviour的单例模式，及泛型单例基类的编写
向宇
09-24 1293
在游戏开发中，单例模式应该是我们最常见也是用的最多的设计模式了，但是你真的了解它吗？本文通过实例分析，我们将阐述如何设计和应用单例模式，以提高代码的可维护性和复用性。无论是初学者还是经验丰富的开发者，这篇文章都将为你提供实用的技巧和深入的理解，帮助你在 Unity 项目中更有效地管理资源和对象。如果要让一个类只有唯一的一个对象，则可以使用单例模式来写。使用的时候用“类名.Instance.成员名”的形式来访问这个对象的成员。
ｃ＋＋单例模式线程池源码示例
jjjxxxhhh123的博客
09-23 384
【代码】ｃ＋＋单例模式线程池源码示例。
继承实现单例模式的探索（一）
最新发布
我与岁月的森林的博客
09-27 239
探索通过继承实现单例模式，而非代码内联。
【Linux】多线程：线程池的创建、日志类、RAII互斥锁、单例模式：饿汉方式与懒汉方式
2301_76606232的博客
09-24 1033
线程池（Thread Pool）是一种基于池化技术的线程使用模式，它创建了一个线程的集合，这些线程可以被多个任务重复使用。线程池的主要目的是减少在创建和销毁线程时所产生的性能开销。 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
前端开发设计模式——单例模式
jxnd123456的博客
09-27 1044
单例模式是一种创建型设计模式，它保证一个类只有一个示例，并提供一个访问它的全局访问点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值