聊一聊单例模式中饿汉、懒汉的联系

小鱼儿 2022-10-29 07:52 104阅读 0赞

## 单例模式——饿汉、懒汉 ##

#### 饿汉 ####

顾名思义，为便于记忆，饿的不行了，所以要类加载时就要“吃”。

public class DatabaseInstance01 {
        
        // 饿汉——初始就要实例化
        private static DatabaseInstance01 instance = new DatabaseInstance01();
    	
        public static DatabaseInstance01 getInstance()
        {
        
            return instance;
        }
        public static void main(String[] args) {
        
            DatabaseInstance01 instance = DatabaseInstance01.getInstance();
            DatabaseInstance01 instance2 = DatabaseInstance01.getInstance();
            System.out.println(instance==instance2);
        }
    }

#### 懒汉 ####

同样，为便于记忆，可理解为，太懒了，最开始不实例化，直到自己需要了，再去实例化。

/**
     * @author 阳光大男孩！！！
     * 懒汉——单例模式
     */
    public class DatabaseInstance02 {
        
        // 太懒了，不实例化
        private static DatabaseInstance02 instance;
        public static DatabaseInstance02 getInstance()
        {
        
            // 只有需要了，再去判断是否实例化一下
            if(instance==null)
            {
        
                instance = new DatabaseInstance02();
            }
            return instance;
        }
    }

可以看出来，饿汉是天生线程安全，而懒汉是线程不安全的。那是不是以后单例模式直接使用饿汉就好了呢？

> 饿汉在类加载的时候就实例化了一个对象，这意味着以后不管用不用这个对象，都将占据内存空间。

所以，一般都是要使用懒汉来实现单例设计模式的，故需要对上面的懒汉进行改进

###### 1.全局访问点加同步,即使用synchronized来加锁，保证正确性 ######

/**
     * @author 阳光大男孩！！！
     * 懒汉——单例模式-全局访问点加同步
     */
    public class DatabaseInstance03 {
        
        private static DatabaseInstance03 instance;
        public synchronized static DatabaseInstance03 getInstance()
        {
        
            if(instance==null)
            {
        
                instance = new DatabaseInstance03();
            }
            return instance;
        }
    }

###### 与 synchronized一样的毛病，它是重量级锁，效率比较低。我们需要进一步优化 ######

1.  这样的好处在于把 synchronized放到了代码块中，从而提高了效率

/**
     * @author 阳光大男孩！！！
     * 懒汉——单例模式
     */
    public class DatabaseInstance04 {
        
        private static DatabaseInstance04 instance;
        
        public  static DatabaseInstance04 getInstance()
        {
        
            if(instance==null)
            {
        
                // 标记处
                synchronized(DatabaseInstance04.class)
                {
        
                    instance = new DatabaseInstance04();
                }
            }
            return instance;
        }
        public static void main(String[] args) {
        
            DatabaseInstance04 instance = DatabaseInstance04.getInstance();
            DatabaseInstance04 instance2 = DatabaseInstance04.getInstance();
            System.out.println(instance==instance2);
        }
    }

仔细观察发现，上面注释标记处很有可能多个线程同时到达，那么就会导致new完一次对象后，再次new一次新的对象，这就出现了线程不安全的问题。

有了上面的分析，我们不难提出解决方案，再次判空即可。

###### 3.双重检查（重要） ######

/**
     * @author 阳光大男孩！！！
     * 懒汉——单例模式-双重检查
     */
    public class DatabaseInstance05 {
        
        private static DatabaseInstance05 instance;
        public  static DatabaseInstance05 getInstance()
        {
        
            if(instance==null)
            {
        
                synchronized(DatabaseInstance05.class)
                {
        
                    if(instance==null)
                    {
        
                        instance = new DatabaseInstance05();
                    }
                }
            }
            return instance;
        }
    }

#### 总结 ####

本文介绍了如何写单例模式，并分析了饿汉和懒汉的区别，以及解决懒汉线程不安全的方法。