设计模式（一）----单例模式

最新推荐文章于 2025-04-29 10:12:49 发布

原创最新推荐文章于 2025-04-29 10:12:49 发布 · 139 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

5 篇文章

订阅专栏

本文深入解析单例模式，包括其定义、特点、实现方式（饿汉式与懒汉式），并探讨了其优缺点及适用场景。通过代码示例，展示了如何在Java中实现线程安全的单例模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义：

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。

特点：

1、单例类只能有一个实例。

　　2、单例类必须自己自己创建自己的唯一实例。

　　3、单例类必须给所有其他对象提供这一实例

单例模式的要点：

1，私有的构造方法

2，指向自己实例的私有静态引用

3，以自己实例为返回值的静态的公有的方法

单例模式根据实例化对象时机的不同分为两种：

一种是饿汉式单例，一种是懒汉式单例。

饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用。

懒汉式在调用取得实例方法的时候才会实例化对象。

/**
 * 单例模式--饿汉式
 * 
 * @author wanting
 *
 */
public class Singleton_Hungry {

	private static Singleton_Hungry INSTANCE = new Singleton_Hungry();

	// 线程安全，但是不管该对象是否被使用，都会存在于内存中
	public static Singleton_Hungry getInstance() {
		return INSTANCE;
	}
}

/**
 * 单例模式--懒汉式（下面的两种都是线程安全的）
 * 
 * @author wanting
 *
 */
public class Singleton_Lazy {

	private static Singleton_Lazy INSTANCE;

	// 锁粒度较粗
	public static synchronized Singleton_Lazy getInstance_1() {
		if (INSTANCE == null) {
			INSTANCE = new Singleton_Lazy();
		}
		return INSTANCE;
	}

	// 利用双重锁的方式将锁粒度减小了
	public static Singleton_Lazy getInstance_2() {
		if (INSTANCE == null) {
			synchronized (Singleton_Lazy.class) {
				if (INSTANCE == null) {
					INSTANCE = new Singleton_Lazy();
				}
			}
		}
		return INSTANCE;
	}
}

单例模式的优点：

1，在内存中只有一个对象，节省内存空间。

2，避免频繁的创建销毁对象，可以提高性能。

3，避免对共享资源的多重占用。

4，可以全局访问。

单例模式的缺点：

1，扩展困难，由于getInstance静态函数没有办法生成子类的实例。如果要拓展，只有重写那个类。

2，隐式使用引起类结构不清晰。

3，导致程序内存泄露的问题。

适用场景：

1，需要频繁实例化然后销毁的对象。

2，创建对象时耗时过多或者耗资源过多，但又经常用到的对象。

3，资源共享的情况下，避免由于资源操作时导致的性能或损耗等

4，控制资源的情况下，方便资源之间的互相通信。

再贴一种懒汉式的另一种的写法：

/**
 * 内部类在使用时才被加载，所以只有在使用时才会存在于内存中；由于 SingletonHolder 是私有的，除了 getInstance()
 * 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。
 * 
 * @author wanting
 *
 */
public class Singleton_Improve {

	private static class SingletonHolder {
		private static final Singleton_Improve INSTANCE = new Singleton_Improve();
	}

	public static final Singleton_Improve getInstance() {
		return SingletonHolder.INSTANCE;
	}
}

单例模式保证反射安全、序列化反序列化安全

public class Singleton_Lazy implements Serializable {

    private static Singleton_Lazy INSTANCE;
    /**
     * 保证反射安全
     */
    public Singleton_Lazy() throws Exception {
        if (INSTANCE != null) {
            throw new Exception("");
        }
    }

    /**
     * 线程安全，锁粒度较小（双重锁）
     *
     * @return
     */
    public static Singleton_Lazy getInstance() throws Exception {
        if (INSTANCE == null) {
            synchronized (Singleton_Lazy.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton_Lazy();
                }
            }
        }
        return INSTANCE;
    }
    /**
     * 保证反序列化安全
     */
    protected Object readResolve() throws Exception {
        return getInstance();
    }
}