单列模式

单例模式是一种常见的设计模式,在网上有许多,一找一大把,我今天看了,所以collection一下:
单例模式分三种:懒汉式单例、饿汉式单例、登记式单例三种。
单例模式有一下特点:
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
一、懒汉式单例
在类被加载的时候,唯一实例已经被创建。这个设计模式在Java中容易实现,在别的语言中难以实现。
/**
*懒汉式单例
*/
public class LazySingleton {
     /**
      * 私有静态对象,加载时候不做初始化
      */
     private static LazySingleton m_intance=null;
     /**
      * 私有构造方法,避免外部创建实例
      */
     private LazySingleton(){
     }
     /**
      * 静态工厂方法,返回此类的唯一实例. 
      * 当发现实例没有初始化的时候,才初始化.
      * @return LazySingleton
      */
     synchronized public static LazySingleton getInstance(){
         if(m_intance==null){
             m_intance=new LazySingleton();
         }
         return m_intance;
     }
}
二、饿汉式单例
在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建,并且只在第一次创建后,以后不再创建该类的实例。
/**
*单例模式-饿汉式单例
*/
public class EagerSingleton {
     /**
      * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象
      */
     private static final EagerSingleton m_instance = new EagerSingleton();
     /**
      * 私有构造方法,避免外部创建实例
      */
     private EagerSingleton() {
     }
     /**
      * 静态工厂方法,返回此类的唯一实例.
      * @return EagerSingleton
      */
     public static EagerSingleton getInstance() {
         return m_instance;
     }
}
三、登记式单例
这个单例实际上维护的是一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从工厂直接返回,对于没有登记的,则先登记,而后返回。
/**
* 单例模式- 登记式单例
*/
public class RegSingleton {
     /**
      * 登记薄,用来存放所有登记的实例
      */
     private static Map<String, RegSingleton> m_registry = new HashMap();
     //在类加载的时候添加一个实例到登记薄
     static {
         RegSingleton x = new RegSingleton();
         m_registry.put(x.getClass().getName(), x);
     }
     /**
      * 受保护的默认构造方法
      */
     protected RegSingleton() {
     }
     /**
      * 静态工厂方法,返回指定登记对象的唯一实例;
      * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回
      * @param name
      * @return RegSingleton
      */
     public static RegSingleton getInstance(String name) {
         if (name == null) {
             name = "RegSingleton";
         }
         if (m_registry.get(name) == null) {
             try {
                 m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());
             } catch (InstantiationException e) {
                 e.printStackTrace();
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             }
         }
         return m_registry.get(name);
     }
     /**
      * 一个示意性的商业方法
      * @return String
      */
     public String about() {
         return "Hello,I am RegSingleton!";
     }
}
四、单例模式的一个应用
该应用是配置文件管理类。为了本例能正确运行,我在C盘下先建立了一个xxxx.properties文件,内容如下:
-------------------
user=root
password=root

这个配置文件管理类的代码如下:
/**
*
* 单例模式应用-单例类应用-配置文件管理
*/
public class ConfigManager {
     /**
      * 属性文件全名
      */
     private static final String PFILE = "C://xxx.properties";
     /**
      * 对应于属性文件的文件对象变量
      */
     private File m_file = null;
     /**
      * 属性文件的最后修改日期
      */
     private long m_lastModifiedTime = 0;
     /**
      * 属性文件所对应的属性对象变量
      */
     private Properties m_props = null;
     /**
      * 本类可能存在的唯一的一个实例
      */
     private static ConfigManager m_instance = new ConfigManager();
     /**
      * 私有构造子,用以保证外界无法直接实例化
      */
     private ConfigManager() {
         m_file = new File(PFILE);
         m_lastModifiedTime = m_file.lastModified();
         if (m_lastModifiedTime == 0) {
             System.err.println(PFILE + " file does not exist!");
         }
         m_props = new Properties();
         try {
             m_props.load(new FileInputStream(PFILE));
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
     /**
      * 静态工厂方法
      *
      * @return ConfigManager
      */
     synchronized public static ConfigManager getInstance() {
         return m_instance;
     }
     /**
      * 获取属性配置项的值
      *
      * @param name
      * @param defaultVal
      * @return Object
      */
     public final Object getConfigItem(String name, Object defaultVal) {
         long newTime = m_file.lastModified();
         if (newTime == 0) {
             //属性文件不存在
             if (m_lastModifiedTime == 0) {
                 System.err.println(PFILE + " file does not exist!");
             } else {
                 System.err.println(PFILE + " file was deleted!");
             }
             return defaultVal;
         } else if (newTime > m_lastModifiedTime) {
             m_props.clear();
             try {
                 m_props.load(new FileInputStream(PFILE));
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         m_lastModifiedTime = newTime;
         Object val = m_props.getProperty(name);
         if (val == null) {
             return defaultVal;
         } else {
             return val;
         }
     }
}
测试配置文件类:
/**
*
* 配置文件管理类测试
*/
public class Test_ConfigManager {
     public static void main(String[] args) {
         ConfigManager cfgm = ConfigManager.getInstance();
         Object val1 = cfgm.getConfigItem("sdf", "leizhimin");
         Object val2 = cfgm.getConfigItem("user", "leizhimin");
         System.out.println(val1.toString());
         System.out.println(val2.toString());
     }
}
运行结果:
root

root
Process finished with exit code 0

### 单例模式的核心概念 单例模式是一种常见的创建型设计模式,其主要目标是确保一个类仅有一个实例存在,并提供一个全局访问点以便于程序中的其他部分可以方便地获取到这唯一的实例[^1]。 #### 单例模式的实现方式 以下是几种主流编程语言中单例模式的具体实现: --- #### **C# 的单例模式实现** 在 C# 中可以通过静态成员和私有构造函数来实现单例模式。下面是一个典型的懒汉式单例模式实现示例: ```csharp public class Singleton { private static Singleton _instance; private static readonly object LockObject = new object(); private Singleton() { } public static Singleton Instance { get { lock (LockObject) { if (_instance == null) _instance = new Singleton(); return _instance; } } } } ``` 此实现在首次调用 `Instance` 属性时才会创建对象,从而实现了延迟初始化的效果[^1]。 --- #### **C++ 的单例模式实现** 对于 C++ 而言,由于其支持更底层的操作特性,因此其实现有一定的复杂度。以下是一个线程安全的单例模式实现: ```cpp #include <iostream> #include <mutex> class Singleton { private: static std::unique_ptr<Singleton> instance; static std::once_flag initFlag; Singleton() {} // 私有构造函数防止外部实例化 public: static Singleton* GetInstance() { std::call_once(initFlag, [](){ instance.reset(new Singleton()); }); return instance.get(); } }; std::unique_ptr<Singleton> Singleton::instance = nullptr; std::once_flag Singleton::initFlag; int main() { Singleton* singleton = Singleton::GetInstance(); return 0; } ``` 通过使用 `std::call_once` 和 `std::once_flag` 来保证即使在多线程环境下也只会有唯一的一个实例被创建[^2]。 --- #### **Java 的单例模式实现** Java 提供了一种非常简洁的方式来实现单例模式——饿汉式单例模式。这种方式会在类加载阶段完成实例化的操作,因而无需担心线程同步问题。 ```java public class SingleInstance { private static final SingleInstance INSTANCE = new SingleInstance(); private SingleInstance() {} public static SingleInstance getInstance() { return INSTANCE; } } ``` 这种实现简单高效,但由于是在类加载期间即已完成实例化,可能会造成内存浪费(如果该实例从未被使用过)。另一种更为灵活的方式则是采用双重校验锁机制(DCL),如下所示: ```java public class DoubleCheckedLockingSingleton { private volatile static DoubleCheckedLockingSingleton uniqueInstance; private DoubleCheckedLockingSingleton() {} public static DoubleCheckedLockingSingleton getInstance() { if (uniqueInstance == null) { synchronized (DoubleCheckedLockingSingleton.class) { if (uniqueInstance == null) { uniqueInstance = new DoubleCheckedLockingSingleton(); } } } return uniqueInstance; } } ``` 这里利用了 Java 内存模型中的 `volatile` 关键字来保障可见性和有序性,同时减少了不必要的加锁开销[^3]。 --- ### 单例模式的应用场景 1. **全局配置管理** 当应用程序需要维护一份统一的配置参数表时,通常会使用单例模式封装这些数据结构,这样能够避免重复读取文件或者数据库带来的性能损耗[^2]。 2. **日志记录器** 日志功能往往贯穿整个项目运行周期,为了简化接口调用流程并减少资源消耗,一般也会将其设计成单例形式。 3. **数据库连接池** 数据库连接属于昂贵资源,频繁建立销毁不仅低效还可能引发异常状况。借助单例模式可有效管理和复用有限数量的连接通道[^2]。 4. **缓存服务** 缓存系统同样适合作为单例处理,因为大多数情况下我们希望所有的模块都能共享同一份最新的缓存内容而不是各自独立存储副本[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值