单例模式(饿汉/懒汉)

/*
饿汉式单例
优点:无须考虑线程安全;从调用速度和反应时间角度来讲,一开始就得以创建,因此要优于懒汉式
缺点:从资源利用效率角度,饿汉式类加载时就创建,利用率低于懒汉式;而且系统的加载时间可能会比较长
*/
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){
			instance = new Singleton();
		}
		return instance;
	}
}

/*
懒汉式线程双重检查锁定单例
优点:从资源利用效率角度要优于饿汉式,解决线程安全问题
缺点:实例化时,多个线程同时访问的几率变大,通过双重检查锁定机制进行控制,可能影响到系统一定的性能
*/
public class Singleton{
	
	public volatile static Singleton instance = null;//volatile关键字修饰确保多个线程都能够正确处理,JDK1.5及以上
	
	private Singleton(){}
	
	public static Singleton getInstance(){
		if(instance == null){//第一重判定
			synchronized(Singleton.class){
				if(instance == null){//第二重判定
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

/*
一种更好的单例实现方式,结合了饿汉式和懒汉式的优点,被称之为Initialization Demand Holder (IoDH)的技术
既可以实现延迟加载,又可以保证线程安全,不影响系统性能,不失为一种最好的Java语言单例模式实现方式
*/
public class Singleton{

	private Singleton(){}
	
	private static class HolderClass{//静态内部类
		private final static Singleton instance = new Singleton();		
	}
	
	public static Singleton getInstance(){
		return HolderClass.instance;
	}
}

### 单例模式中的饿汉式懒汉实现 #### 饿汉式(Eager Initialization) 饿汉式是一种在类加载时就创建对象的方,因此它天生是线程安全的。由于实例是在定义阶段就被初始化,所以不需要额外考虑多线程环境下的同步问题。 以下是C++和Java饿汉式的实现: ##### C++ 实现 ```cpp #include <iostream> class Singleton { private: static Singleton instance; // 静态成员变量,在类外部初始化 Singleton() { std::cout << "Constructor called." << std::endl; } public: static Singleton& getInstance() { return instance; } }; // 类外初始化静态成员变量 Singleton Singleton::instance; int main() { Singleton& obj = Singleton::getInstance(); return 0; } ``` 上述代码展示了如何通过提前声明并初始化 `static` 成员变量来实现饿汉式单例[^3]。 ##### Java 实现 ```java package singleton; /** * @author ExampleAuthor */ public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} public static Singleton getInstance() { return INSTANCE; } } ``` 此版本利用了 `final` 关键字确保实例不可被修改,并且因为 JVM 的类加载机制,该实例会在第一次访问时完成初始化[^2]。 --- #### 懒汉(Lazy Initialization) 懒汉是指当真正需要使用到某个对象的时候才去创建它的实例。这种方可以节省内存资源,但在多线程环境下需要注意线程安全性。 以下是两种不同场景下懒汉的实现方——线程不安全版与双重检查锁定版。 ##### C++ 实现 - 线程不安全 ```cpp #include <iostream> using namespace std; class Singleton { private: static Singleton* pInstance; Singleton() {} public: static Singleton* getInstance() { if (!pInstance) { pInstance = new Singleton(); // 可能存在竞争条件 } return pInstance; } }; Singleton* Singleton::pInstance = nullptr; int main() { Singleton* s1 = Singleton::getInstance(); Singleton* s2 = Singleton::getInstance(); cout << (s1 == s2 ? "Same Instance" : "Different Instances") << endl; delete s1; return 0; } ``` 这种简单形未处理并发情况,可能导致多个线程同时进入判断语句从而生成多个实例。 ##### C++ 实现 - 使用双重检查锁(Double-Checked Locking Pattern, DCLP) ```cpp #include <mutex> #include <iostream> using namespace std; class Singleton { private: static Singleton* pInstance; static mutex mtx; Singleton() {} public: static Singleton* getInstance() { if (!pInstance) { // 第一次检查 lock_guard<mutex> lock(mtx); // 加锁防止竞态条件 if (!pInstance) { // 第二次检查 pInstance = new Singleton(); } } return pInstance; } }; Singleton* Singleton::pInstance = nullptr; mutex Singleton::mtx; int main() { Singleton* s1 = Singleton::getInstance(); Singleton* s2 = Singleton::getInstance(); cout << (s1 == s2 ? "Same Instance" : "Different Instances") << endl; delete s1; return 0; } ``` 这里引入了互斥量 (`std::mutex`) 来保护临界区,避免因多线程引发的竞争状态。 ##### Java 实现 - 基本懒汉 ```java package singleton; /** * @author ExampleAuthor */ public class Singleton { private static Singleton instance = null; private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` 在这个例子中,整个方法都被标记为 `synchronized`,虽然能够解决线程安全问题,但性能开销较大。 ##### Java 实现 - 双重检查锁定(DCLP) ```java package singleton; /** * @author ExampleAuthor */ public class Singleton { private volatile static Singleton instance = null; private Singleton() {} public static Singleton getInstance() { if (instance == null) { // 第一层检测 synchronized (Singleton.class) { if (instance == null) { // 第二层检测 instance = new Singleton(); } } } return instance; } } ``` 为了保证可见性和避免指令重排序带来的潜在风险,此处还加入了关键字 `volatile`。 --- #### 总结 无论是哪种语言,饿汉式都因其简单的结构以及天然具备的线程安全性而受到青睐;然而如果希望延迟实例化,则需采用适当措施保障懒汉的正确运行,尤其是在支持多线程的应用程序里更应如此注意细节差异。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值