Java面试 - 什么是单例设计模式,为什么要使用单例设计模式,如何实现单例设计模式(饿汉式和懒汉式)?

时间:2023-03-08 16:43:37

什么是单例设计模式?

单例设计模式就是一种控制实例化对象个数的设计模式。

为什么要使用单例设计模式?

使用单例设计模式可以节省内存空间,提高性能。因为很多情况下,有些类是不需要重复产生对象的。

如果重复产生对象的话,会导致大量的内存空间被占用,性能降低。

例如:在程序启动中,加载已保存的数据信息。这些数据信息是由一个单例对象统一读取,其他程序只需要通过这个单例对象获取加载的数据信息即可。

单例设计模式分为饿汉式和懒汉式。饿汉式是在系统加载类的时候就会自动提供类的实例化对象如Computer computer。

懒汉式是在第一次使用的时候进行实例化对象处理。

饿汉式单例设计模式实现源码:

class Computer{

  //1、私有化 Computer 构造函数
private Computer(){
System.out.println("私有化 Computer 构造函数");
}
public void printInfo(){
System.out.println("Computer 类使用的就是单例设计模式");
} // 2、调用私有化 Computer 构造函数并将computer属性设置为static
private static Computer computer = new Computer(); // 3、提供getCompter()方法,便于调用
public static Computer getCompter(){
return computer;
}
} public class Demo { public static void main(String[] args) {
// 产生单例对象
Computer computer = Computer.getCompter(); // 调用printInfo()方法
computer.printInfo();
}
}

运行结果:

私有化 Computer 构造函数
Computer 类使用的就是单例设计模式

饿汉式单例设计模式的实现过程分析:

1、所有新的实例化对象的产生都会调用构造方法,如果无法正常调用构造方法的话,也就不能产生新的实例化对象。

如果想控制实例化对象个数的话,那么就应该控制构造函数。因此首先将该类的构造方法定义为私有方法。

private Computer(){
System.out.println("私有化Computer 构造函数");
}

2、类的构造方法私有化后,在类的外部就不能产生实例化对象。但是Private 修饰的构造方法可以在类的内部访问。

如果要访问Private 修饰的构造方法,可以在类的内部调用构造函数。

private Computer computer = new Computer();

3、computer 作为普通属性,只有在实例化对象产生之后才能被调用。由于类的外部无法产生实例化对象,如果想获取

computer 属性,可以将computer 属性设置为static。

private static Computer computer = new Computer();

4、对于private 属性 computer来说,如果想在类的外部获取该属性,则需要通过getComputer()方法获取。

public static Computer getCompter(){
return computer;
}

由于饿汉式在类加载的时候就完成了对象实例化,如果程序始终没有用到这个实例化对象,那么就会造成内存空间的浪费。

为了不浪费内存空间,懒汉式是在第一次使用的时候进行实例化对象处理。

懒汉式单例设计模式实现源码:

class Computer{

  //1、私有化 Computer 构造函数
private Computer(){
System.out.println("私有化 Computer 构造函数");
}
public void printInfo(){
System.out.println("Computer 类使用的就是单例设计模式");
} // 2、调用私有化 Computer 构造函数并将computer属性设置为static
private static Computer computer; // 3、提供getCompter()方法,便于调用
public static Computer getCompter(){ // 懒汉式,按需创建 即在第一次使用的时候进行实例化对象
if(computer == null){
computer = new Computer();
}
return computer;
}
} public class Demo {
public static void main(String[] args) {
// 产生单例对象
Computer computer = Computer.getCompter(); // 调用printInfo()方法
computer.printInfo();
}
}

运行结果:

私有化 Computer 构造函数
Computer 类使用的就是单例设计模式

懒汉式单例设计模式的实现源码分析:

为了避免实例化的对象始终没有被使用,造成内存空间的浪费,所以增加了对实例化对象的判断,

即如果实例化对象为null 则创建实例化对象。

// 懒汉式,按需创建 即只有在第一次使用的时候才进行实例化对象
if(computer == null){
computer = new Computer();
}

但是如果在多线程下,会出现这样的情况即一个线程进入了if 语句, 另一个线程也通过了if语句。

这样就产生了多个实例化对象。 为了避免这样的问题,可以采用双重加锁机制。

双重加锁机制优化懒汉式源码:

class Computer{
//1、私有化 Computer 构造函数
private Computer(){
System.out.println("私有化 Computer 构造函数");
} public void printInfo(){
System.out.println("Computer 类使用的就是单例设计模式");
} // 2、调用私有化 Computer 构造函数并将computer属性设置为static
private volatile static Computer computer; // 3、提供getCompter()方法,便于调用
public static Computer getCompter(){
// 第一次检查
if(computer == null){
// 加锁
synchronized (Computer.class){
// 第二次检查
if (computer == null){
computer = new Computer();
}
}
}
return computer;
}
} public class Demo {
public static void main(String[] args) {
// 产生单例对象
Computer computer = Computer.getCompter(); // 调用printInfo()方法
computer.printInfo();
}
}

运行结果:

私有化 Computer 构造函数
Computer 类使用的就是单例设计模式

双重加锁机制优化懒汉式源码分析:

 // 2、调用私有化 Computer 构造函数并将computer属性设置为static
private volatile static Computer computer; // 3、提供getCompter()方法,便于调用
public static Computer getCompter(){
// 第一次检查
if(computer == null){
// 加锁
synchronized (Computer.class){
// 第二次检查
if (computer == null){
computer = new Computer();
}
}
}
return computer;
}

1、volatile可以保证多线程下的可见性即保证了子线程的会跟主线程的一致。

2、当thread2,进入第一个if(computer == null) 语句,子线程的computer为空的,thread2释放资源给thread3。

3、当thread3,进入第一个if(computer == null) 语句,子线程的computer为空的,thread3释放资源给thread2。

4、当thread2,进入第二个if(computer == null) 语句,执行computer = new Computer(),实例化对象computer,volatile修饰的变量computer,会马上同步到主线程的变量computer,执行完成后thread2释放资源给thread3。

5、当thread3,进入第二个if (computer == null) 语句,此时子线程的computer不为空,所以thread3不再会重复实例化computer。