前言:
单例设计模式是一种创建对象的模式,保证这个类只有一个实例对象
为什么要使用单例?
1、减少对象内存占用
2、共享资源
3、减少对象创建时间,提高性能
三种模式:
饿汉式
懒汉式
双重验证
代码:
饿汉式:
package com.xhx.designpattern;
import java.util.Objects;
public class Person {
private String name;
//构造函数私有化
private Person(){}
//饿汉式 多线程中可以保证是一个对象
private static final Person person = new Person();
//提供一个全局的静态方法
public static Person getPerson(){
return person;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
懒汉式1:
package com.xhx.designpattern;
import java.util.Objects;
public class Person2 {
private String name;
//构造函数私有化
private Person2(){}
//懒汉式 多线程中不可以保证是一个对象
private static Person2 person ;
//提供一个全局的静态方法
public static Person2 getPerson(){
if(Objects.isNull(person)){
person=new Person2();
}
return person;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
懒汉式2:
package com.xhx.designpattern;
import java.util.Objects;
public class Person3 {
private String name;
//构造函数私有化
private Person3(){}
//懒汉式 多线程中不可以保证是一个对象
private static Person3 person ;
//提供一个全局的静态方法 解决方案,使用同步方法
//缺点:影响效率
public static synchronized Person3 getPerson(){
if(Objects.isNull(person)){
person=new Person3();
}
return person;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
懒汉式3:
package com.xhx.designpattern;
import java.util.Objects;
public class Person4 {
private String name;
//构造函数私有化
private Person4(){}
//懒汉式 多线程中不可以保证是一个对象
private static Person4 person ;
//提供一个全局的静态方法
// 解决方案,同步代码块,双重验证
public static Person4 getPerson(){
if(Objects.isNull(person)){
synchronized (Person4.class) {
if(Objects.isNull(person)) {
person = new Person4();
}
}
}
return person;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}