单例模式代码怎么写 (单例模式代码实现)
本文目录导航：
单例模式代码怎么写？
单例模式(Singleton) ,属于最常见的设计模式之一，大部分系统都会用到，目的是为了维护系统中唯一的一个实例。
\x0d\x0a可分为eager模式，示例代码如下：\x0d\x0aJava代码\x0d\ EagerSingleton{\x0d\x0a2. private static final EagerSingleton m_instance = new EagerSingleton();\x0d\x0a3. private EagerSingleton(){}\x0d\x0a4. public static EagerSingleton getInstance(){\x0d\x0a5. return m_instance;\x0d\x0a6. }\x0d\x0a7.}\x0d\x0aclass EagerSingleton{\x0d\x0aprivate static final EagerSingleton m_instance = new EagerSingleton();\x0d\x0aprivate EagerSingleton(){}\x0d\x0apublic static EagerSingleton getInstance(){\x0d\x0areturn m_instance;\x0d\x0a}\x0d\x0a}\x0d\x0a和 lazy模式，示例代码如下：\x0d\x0aJava代码\x0d\ LazySingleton{\x0d\x0a2. private static LazySingleton m_instance = null;\x0d\x0a3. private LazySingleton(){}\x0d\x0a4. public synchronized static getInstance(){\x0d\x0a5. if(m_instance == null){\x0d\x0a6. m_instance = new LazySingleton();\x0d\x0a7. }\x0d\x0a8. return m_instance;\x0d\x0a9. }\x0d\x0a10.}\x0d\x0aclass LazySingleton{\x0d\x0aprivate static LazySingleton m_instance = null;\x0d\x0aprivate LazySingleton(){}\x0d\x0apublic synchronized static getInstance(){\x0d\x0aif(m_instance == null){\x0d\x0am_instance = new LazySingleton();\x0d\x0a}\x0d\x0areturn m_instance;\x0d\x0a}\x0d\x0a}\x0d\x0ajava源码中，()就是单例的一个例子。
\x0d\x0a单例模式的精神就是整个系统中维护一个实例，推广开来，如果在一个系统中需要维护多个示例，那么就产生了多例模式(multiton)。
\x0d\x0a多例模式(Multiton) ,通过聚集对象了保留自身的多个示例，根据客户端的参数返回所需要的实例。
\x0d\x0a示例代码如下：\x0d\x0aJava代码\x0d\ Multiton{\x0d\x0a2. private final int INSTANCE_SIZE = 10;\x0d\x0a3. private static Map instances = new HashMap(INSTANCE_SIZE);\x0d\x0a4. private String name;\x0d\x0a5. private Multiton(){}\x0d\x0a6. private Multiton(String name){\x0d\x0a7. = name;\x0d\x0a8. }\x0d\x0a9. public synchronized static getInstance(String name){\x0d\x0a10. if((name)){\x0d\x0a11. return (name);\x0d\x0a12. }\x0d\x0a13. else{\x0d\x0a14. ins = new Multiton(name);\x0d\x0a15. (name, ins);\x0d\x0a16. return ins;\x0d\x0a17. }\x0d\x0a18. }\x0d\x0a19.}\x0d\x0aclass Multiton{\x0d\x0aprivate final int INSTANCE_SIZE = 10;\x0d\x0aprivate static Map instances = new HashMap(INSTANCE_SIZE);\x0d\x0aprivate String name;\x0d\x0aprivate Multiton(){}\x0d\x0aprivate Multiton(String name){\x0d\ = name;\x0d\x0a}\x0d\x0apublic synchronized static getInstance(String name){\x0d\x0aif((name)){\x0d\x0areturn (name);\x0d\x0a}\x0d\x0aelse{\x0d\x0ains = new Multiton(name);\x0d\(name, ins);\x0d\x0areturn ins;\x0d\x0a}\x0d\x0a}\x0d\x0a}\x0d\x0a[nextpage]\x0d\x0a一个实用的例子就是KeyGenerator, 示例代码如下：\x0d\x0aJava代码\x0d\ KeyGenerator{\x0d\x0a2. private final int POOL_SIZE = 20;\x0d\x0a3. private static Map instances = new HashMap(16);\x0d\x0a4. private KeyInfo keyinfo;\x0d\x0a5. private KeyGenerator(){}\x0d\x0a6. private KeyGenerator(String keyName){\x0d\x0a7. = new KeyInfo(POOL_SIZE, keyName);\x0d\x0a8. }\x0d\x0a9. public synchronized static getInstance(String keyName){\x0d\x0a10. if((keyName)){\x0d\x0a11. return (KeyGenerator)(keyName);\x0d\x0a12. }\x0d\x0a13. else{\x0d\x0a14. keyGen = new KeyGenerator(keyName);\x0d\x0a15. (name, keyGen);\x0d\x0a16. return keyGen;\x0d\x0a17. }\x0d\x0a18. }\x0d\x0a19. public synzhronized int getNextKey(){\x0d\x0a20. return ();\x0d\x0a21. }\x0d\x0a22. }\x0d\x0aclass KeyGenerator{\x0d\x0aprivate final int POOL_SIZE = 20;\x0d\x0aprivate static Map instances = new HashMap(16);\x0d\x0aprivate KeyInfo keyinfo;\x0d\x0aprivate KeyGenerator(){}\x0d\x0aprivate KeyGenerator(String keyName){\x0d\ = new KeyInfo(POOL_SIZE, keyName);\x0d\x0a}\x0d\x0apublic synchronized static getInstance(String keyName){\x0d\x0aif((keyName)){\x0d\x0areturn (KeyGenerator)(keyName);\x0d\x0a}\x0d\x0aelse{\x0d\x0akeyGen = new KeyGenerator(keyName);\x0d\(name, keyGen);\x0d\x0areturn keyGen;\x0d\x0a}\x0d\x0a}\x0d\x0apublic synzhronized int getNextKey(){\x0d\x0areturn ();\x0d\x0a}\x0d\x0a}
设计模式之单例模式
单例设计模式理解起来非常简单。
一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫单例模式。
下面的示例中如果每个类都创建一个 Logger 实例，就可能造成日志内容被覆盖的情况。
如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。
比如，配置信息类，全局 ID 生成器等。
要实现一个单例，我们要考虑以下几点：
懒汉式相对于饿汉式的优势是「支持延迟加载」 。
但缺点也很明显，因为使用了 synchronized 关键字导致这个方法的「并发度很低」 。
如果这个单例类偶尔会被用到，那这种实现方式还可以接受。
但是，如果频繁地用到，就会导致性能瓶颈，这种实现方式就不可取了。
这是一种既支持延迟加载、又支持高并发的单例实现方式。
在 java1.5 以下 instance = new Singleton(); 有指令重排问题，需要给 instance 成员变量加上 volatile 关键字，java1.5 之后不会再这个问题。
这种方式利用了 Java 的静态内部类，有点类似饿汉式，但又能做到了延迟加载。
当外部类 Singleton 被加载的时候，并不会创建 SingletonHolder 实例对象。
只有当调用 getInstance() 方法时，SingletonHolder 才会被加载，这个时候才会创建 instance。
insance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。
所以，这种实现方法既保证了线程安全，又能做到延迟加载。
这是一种最简单的实现方式，基于枚举类型的单例实现。
这种实现方式是通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。
上面的单例类对象是进程唯一的，一个进程只能有一个单例对象。那如何实现一个线程唯一的单例呢？
假设 IdGenerator 是一个线程唯一的单例类。
在线程 A 内，我们可以创建一个单例对象 a。
因为线程内唯一，在线程 A 内就不能再创建新的 IdGenerator 对象了，而线程间可以不唯一，所以，在另外一个线程 B 内，我们还可以重新创建一个新的单例对象 b。
我们通过一个 ConcurrentHashMap 来存储对象，其中 key 是线程 ID，value 是对象。
这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。
实际上，Java 语言本身提供了 ThreadLocal 工具类，可以更加轻松地实现线程唯一单例。
设计模式之单例 —— Unity
单例模式，作为设计模式中的基础之一，其核心理念是确保一个类在全球范围内只有一个实例。
这个实例负责自身对象的创建，并确保在整个程序中只有一个实例存在。
让我们从实现、应用场景以及注意事项等方面来探讨单例模式： 实现单例通常采用私有构造函数和私有静态实例变量的方法。
首先，创建一个私有构造函数，防止外部直接实例化对象，接着，通过一个静态方法返回并初始化这个唯一实例，如下所示：javapublic class Singleton {private static Singleton instance;// 私有构造函数private Singleton() {}// 获取唯一实例public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}}然而，这种实现方式在多线程环境下可能会出现问题，因为它会在第一次调用时初始化。
为确保线程安全，可以使用双重检查锁定（Double-Checked Locking）技术，具体实现如下：javapublic class Singleton {private volatile static Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance == null) {synchronized () {if (instance == null) {instance = new Singleton();}}}return instance;}}在Unity游戏开发中，单例模式常用于资源管理（如声音、网络请求、UI管理），以简化代码、提高维护性。
同时，它在性能优化中也有应用，比如对象池技术。
然而，使用单例时需注意其潜在问题，如类状态的持久性和性能开销。
对于复杂场景，可能需要权衡或选择其他设计模式。
以上内容仅供参考，如有错误，欢迎指正。
对于进一步交流，你可以加入Unity开发交流群。
phper