单例模式-饿汉式懒汉式

//测试类
@SpringBootApplication
public class Application {

public static void main(String[] args) {
    // SpringApplication.run(Application.class, args);
  //单例模式（饿汉式）
    //再次证明了构造方法私有化不能创建对象
    //Person person=new Person();
    Person person1=Person.getPerson();
    person1.setName("zhangsan");
    Person person2=Person.getPerson();
    person2.setName("lisi");
    System.out.println(person1.getName());
    System.out.println(person2.getName());

    System.out.println("***********分隔符*********");
    
    //单列模式（懒汉式）
    Man man1=Man.getMan();
    Man man2=Man.getMan();
    man1.setName("lisi");
    man1.setName("zhangsan");
    System.out.println(man1.getName());
    System.out.println(man2.getName())；
}

}
package com.bjpowernode.singleton;

;

//饿汉式类
public class Person {
//构造方法私有化之后，就不能new对象了，这时候必须要提供一个全局的静态方法，不然这是一个僵尸类
private Person(){};
//final修饰的静态常量，类加载生成一次
public static final Person person = new Person();
private String name;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

//定义一个静态的全局方法
public static Person getPerson() {
return person;
}
}

//懒汉式类

public class Man {
private Man(){};
private String name;
private static Man man;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
//这里加一个同步方法锁，解决线程安全的问题，否则在多线程的情况下可能会创建俩个对象。但是这样会导致线程等待，造成线程阻塞。
//方法1：

/* public static synchronized Man getMan(){
if (mannull){
man=new Man();
}
return man;
}*/
方法2：双重检查
public static Man getMan(){
if(mannull){
synchronized(Man.class){
if(man==null){
man=new Man();
}
}
return man;
}
}

}
//测试结果

lisi
lisi
**分隔符
zhangsan
zhangsan

Process finished with exit code 0