本关任务 请补全代码,写出单例模式之饿汉式 。任务描述: 获取的对象地址相同,相关知识 :饿汉单例设计模式 在用类获取对象的时候,对象已经提前为你创建好了。 设计步骤 1.定义一个类,把构造器私有。 2.
时间: 2023-12-31 18:03:59 浏览: 68
在类中定义一个私有的静态变量来保存单例对象。
3.提供一个公共的静态方法来获取该单例对象,该方法需要判断单例对象是否已经被创建,如果已经被创建则直接返回该单例对象,否则先创建该单例对象再返回。
饿汉式单例模式代码实现如下:
```java
public class Singleton {
// 定义一个私有的静态变量来保存单例对象
private static Singleton instance = new Singleton();
// 将构造器私有化,不允许外部直接创建对象
private Singleton() {}
// 提供一个公共的静态方法来获取该单例对象
public static Singleton getInstance() {
return instance;
}
}
```
在上面的代码中,我们在类定义中直接创建了一个单例对象,并将其保存在了一个静态变量中。同时,我们将构造器私有化,不允许外部直接创建对象。在获取单例对象的时候,我们通过公共的静态方法来获取该单例对象。如果单例对象已经被创建,则直接返回该单例对象,否则先创建该单例对象再返回。这样就可以保证获取的对象地址相同,实现了饿汉式单例模式。
相关问题
请写单例模式(饿汉式, 懒汉式), 请再写出线程安全的单例模式
饿汉式单例模式:
```java
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}
```
懒汉式单例模式:
```java
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
```
线程安全单例模式:
```java
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
```
在多线程环境下,如果不加 synchronized 关键字,则可能会出现多个实例的情况。为了避免这种情况,需要加上 synchronized 关键字。但是这样会导致性能下降,因为每次获取实例时都需要加锁,即使实例已经创建了。为了避免这种情况,可以使用双重检查锁定机制,即在 synchronized 关键字内部再进行一次 if 判断,这样就可以避免每次都加锁的情况。同时需要注意的是,为了避免指令重排带来的问题,需要在 instance 变量前加上 volatile 关键字。
用C++写出懒汉式单例模式和饿汉式单例模式的例子
以下是C++中懒汉式单例模式和饿汉式单例模式的例子:
1. 饿汉式单例模式
```cpp
class Singleton {
private:
static Singleton* instance;
Singleton() {} // 私有构造函数
public:
static Singleton* getInstance() {
return instance;
}
};
Singleton* Singleton::instance = new Singleton(); // 在类外初始化静态成员变量
int main() {
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
if (s1 == s2) {
cout << "s1和s2是同一个实例" << endl;
}
return 0;
}
```
2. 懒汉式单例模式
2.1 简易版
```cpp
class Singleton {
private:
static Singleton* instance;
Singleton() {} // 私有构造函数
public:
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
};
Singleton* Singleton::instance = nullptr; // 在类外初始化静态成员变量
int main() {
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance(); if (s1 == s2) {
cout << "s1和s2是同一个实例" << endl;
}
return 0;
}
```
2.2 私有嵌套类-回收专用
```cpp
class Singleton {
private:
Singleton() {} // 私有构造函数
~Singleton() {} // 私有析构函数
static Singleton* instance;
class GarbageCollector { // 私有嵌套类
public:
~GarbageCollector() {
if (Singleton::instance != nullptr) {
delete Singleton::instance;
Singleton::instance = nullptr; }
}
};
static GarbageCollector gc; // 静态成员变量,程序结束时自动调用析构函数
public:
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
};
Singleton* Singleton::instance = nullptr; // 在类外初始化静态成员变量
Singleton::GarbageCollector Singleton::gc; // 在类外初始化静态成员变量
int main() {
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
if (s1 == s2) {
cout << "s1和s2是同一个实例" << endl;
}
return 0;
}
```