如何在java中实现singleton模式 (如何在jaVa版上玩烦人的村民)

本文目录导航：

• 如何在java中实现singleton模式
• 单例模式代码怎么写？
• 单例模式单例模式实例

如何在java中实现singleton模式

单例模式是设计模式中的一种，主要目的是确保一个类只有一个实例，并提供一个全局访问点。

在Java中，实现单例模式的方法有五种：懒汉式、饿汉式、静态内部类、枚举和双重检查锁定。

懒汉式是使用最广泛的一种实现方式。

它通过在类内部定义一个静态私有变量，并在类的内部方法中进行实例的初始化。

当首次调用getInstance方法时，会创建实例并返回。

懒汉式的实现如下：class LazySingleton { private static LazySingleton singleton; private LazySingleton() {} public static LazySingleton getInstance() { if (singleton == null) { singleton = new LazySingleton(); } return singleton; }}饿汉式则是在类加载时即创建实例，这种方式保证了线程安全，但是可能造成资源浪费，因为类加载时实例就已经被创建了。

饿汉式的实现如下：class HungrySingleton { private static HungrySingleton singleton = new HungrySingleton(); private HungrySingleton() {} public static HungrySingleton getInstance() { return singleton; }}静态内部类的实现则是在第一次使用时才加载内部类，从而实现延迟加载。

这种方式既能保证线程安全，又不会在类加载时就创建实例。

静态内部类的实现如下：class InternalSingleton { private static class SingletonHolder { private final static InternalSingleton INSTANCE = new InternalSingleton(); } private InternalSingleton() {} public static InternalSingleton getInstance() { return ; }}枚举实现则通过枚举类型来保证实例的唯一性，并且可以防止反序列化重新创建新的对象。

枚举实现如下：enum EnumSingleton { INSTANCE; public void doSomeThing() { // do something }}最后一种是双重检查锁定，虽然在某些情况下可以提高性能，但在Java的当前内存模型中，这种方式是无效的。

双重检查锁定的实现如下：class LockSingleton { private volatile static LockSingleton singleton; private LockSingleton() {} public static LockSingleton getInstance() { if (singleton == null) { synchronized () { if (singleton == null) { singleton = new LockSingleton(); } } } return singleton; }}

单例模式代码怎么写？

单例模式(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}

单例模式单例模式实例

在Java中，单例模式确保一个类Class只有一个实例存在。

这种模式主要作用在于控制类的实例创建过程，确保所有对象都能访问到唯一实例，以实现实例控制、灵活性和减少内存占用。

单例模式实例代码如下：

public class Singleton {

private static Singleton instance = null;

private Singleton(){

//初始化代码

public static Singleton getInstance(){

if(instance == null){

instance = new Singleton();

return instance;

以下是三种常见形式：

第一种：最常用形式

public class Singleton {

private static Singleton instance = null;

private Singleton(){

//初始化代码

public static Singleton getInstance(){

if(instance == null){

instance = new Singleton();

return instance;

第二种：内部类形式

public class Singleton {

private static Singleton instance = new Singleton();

private Singleton(){

//初始化代码

public static Singleton getInstance(){

return instance;

第三种：双重检查锁形式

public class Singleton {

private static Singleton instance = null;

private Singleton(){

//初始化代码

public static Singleton getInstance(){

if(instance == null){

synchronized(){

if(null == instance){

instance = new Singleton();

return instance;

在Flex中，可以使用`ModelLocator`类实现单例模式，其内部完成了自身的实例化。

javascript

package models

[Bindable]

public class ModelLocator extends EventDispatcher {

public static var _instance:ModelLocator;

public static function getInstance():ModelLocator {

if(_instance == null){

_instance = new ModelLocator();

return _instance;

C#中实现单例模式类似，确保实例唯一性并提供全局访问点。

// 用法说明

// 保证一个类仅有一个实例，并提供一个访问它的全局访问点

// 实现要点

// Singleton模式是限制而不是改进类的创建。

// Singleton类中的实例构造器可以设置为Protected以允许子类派生。

// Singleton模式一般不要支持Icloneable接口，因为这可能导致多个对象实例，与Singleton模式的初衷违背。

// Singleton模式一般不要支持序列化，这也有可能导致多个对象实例，这也与Singleton模式的初衷违背。

// Singleton只考虑了对象创建的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开销来讲，我们一般没必要对其销毁进行特殊的管理。

// 理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。

// 可以很简单的修改一个Singleton，使它有少数几个实例，这样做是允许的而且是有意义的。

// 优点

// 实例控制：Singleton会阻止其他对象实例化其自己的Singleton对象的副本，从而确保所有对象都访问唯一实例

// 灵活性：因为类控制了实例化过程，所以类可以更加灵活修改实例化过程

// 缺点

// 开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。

可以通过使用静态初始化解决此问题。

// 可能的开发混淆：使用singleton对象时，开发人员必须记住自己不能使用new关键字实例化对象。

因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

// 对象的生存期：Singleton不能解决删除单个对象的问题。

单例模式在不同场景下有着广泛的应用，比如确保系统中有且只有一个窗口管理器、打印机或COM口实例等。

单例模式是一种常用的软件设计模式。

在它的核心结构中只包含一个被称为单例类的特殊类。

通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。

如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。