java中关于懒汉式和饿汉式的个人理解

单例模式

解决的问题：
如何使一个类只在内存中存在一个实例对象；

饿汉式

从线程的安全性来看，饿汉式天生是线程安全的

class Demo{
    //构造函数私有化
    private Demo(){
    }
    
    //定义一个静态私有的对象
   private static Demo demo=new Demo()
   
   //定义一个方法，用来获取类对象
   public static Demo getInstance(){
       return demo;
   }
}

分析：
构造函数私有化是为了使得不能通过类去创建类对象，然后定义一个静态私有的对象，使得该对象在类被加载的时候也同时加载,最后定义一个公有方法去获得该对象

懒汉式

从线程的安全性来看，懒汉式是线程不安全的

class Demo{
    //定义私有构造函数
    private Demo(){  
    }
    //定义一个静态私有对象
    private static Demo demo=null;
    //定义一个公有方法给私有对象赋值
    public static Demo getInstance(){
        if(demo==null){
            demo=new Demo();
            return demo;
        }
    }   
}

分析：
懒汉式与饿汉式的区别就是不是在类被加载的时候就在内存中创建对象，而是当调用方法的时候才创建对象，是一种延迟加载的方式，可是这种方式存在弊端，当多个线程执行时，当一个线程创建完对象还没有返回对象时，cpu把执行权限给了另一个线程，这时候另一个线程也会创建一个对象，这样就会导致线程不安全。

优化方式一：使用synchronized关键字
分析：
当给方法加上synchronized锁.时，当线程进入该方法时，会带上这个锁的钥匙，这把钥匙是唯一的，只有当线程将方法运行结束，锁才会得到释放，别的线程才能进入该方法
优点：
线程变得安全
缺点：
效率会低，每个线程使用这个方法都需要判断是否带有钥匙

class Demo{
    //定义私有构造函数
    private Demo(){  
    }
    //定义一个静态私有对象
    private static  Demo demo=null;
    //定义一个公有方法给私有对象赋值
    public static synchronized Demo getInstance(){
        if(demo==null){
            demo=new Demo();
            return demo;
        }
    }   
}

优化方式二: 使用双重判断

当有多个线程时，从第三个线程开始就不需要进行锁的判断了,减少了线程对是否具有锁的钥匙判断，提高了效率

class Demo{
    //定义私有构造函数
    private Demo(){  
    }
    //定义一个静态私有对象
    private static  Demo demo=null;
    //定义一个公有方法给私有对象赋值
    public static  Demo getInstance(){
        if(s==null){
            synchronized(Demo.class){
                 if(demo==null){
            demo=new Demo();
            }
        }
        return demo;
    }   
}

总结：
对于事物的描述该怎么描述还是怎么描述，只是当需求变为只需要一个该事物的对象时，将以上方法加入即可，推荐优先使用饿汉式。