Java单例模式详解：懒汉式与饿汉式实现及优缺点,-优快云博客

本文链接：https://blog.youkuaiyun.com/sky_20131213/article/details/132570802

一、什么是单例模式

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。单例模式的主要角色如下。

单例类：包含一个实例且能自行创建这个实例的类。
访问类：使用单例的类。

二、单例模式的实现

单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。
单例模式有懒汉式和饿汉式两种实现：
1、懒汉式实现
该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。在实现懒汉式的时候要注意保证线程的安全性，可以通过加锁或者延迟初始化占位类两种方式保证创建单例的线程安全，一般使用延迟初始化占位类保证线程安全，其中延迟初始化占位类是通过类加载的线程安全性来保证初始化单例的线程安全。

通过加锁实现：


/**
 * 懒汉单例模式  当有方法调用getInstance方法的时候才会创建一个对象
 * Volatile 与 synchronized  保证了单例在多线程中的线程安全
 * 一般不使用
 */
public class LazySingleton {
    //volatile 保证 instance 在所有线程中同步 解决重排序问题
    private volatile static LazySingleton lazySingleton;

    private LazySingleton(){}

    public static  LazySingleton getInstance(){
        if (lazySingleton==null){
            //生成对象时的重排序有可能使对象为完成创建却通过这个判断，通过volatile解决
            synchronized (LazySingleton.class){
                if (lazySingleton==null){
                    //分配内存
                    //空间初始化
                    //将引用指向空间地址
                    lazySingleton = new LazySingleton();
                }
            }
        }
        return lazySingleton;
    }
}

通过延迟初始化占位类实现：

/**
 * 懒汉-延迟初始化占位类模式
 * 使用类加载的线程安全
 */
public class LazySingleInit {

    private LazySingleInit(){}

    private static class InstanceHolder{
        private static final LazySingleInit instance = new LazySingleInit();
    }
    public static LazySingleInit getInstance(){
        return InstanceHolder.instance;
    }

}

2、饿汉式实现
该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。由于饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

/**
 * 饥饿加载  类加载的时候立即创建对象
 */
public class HungrySingleton {
    //在创建class类的时候就创建对象，利用类加载器特性 保证了线程的安全
    private static final HungrySingleton HUNGRY_SINGLETON=new HungrySingleton();

    private HungrySingleton(){
    }

    public static HungrySingleton getInstance(){
        return HUNGRY_SINGLETON;
    }
}

3、测试代码


import org.junit.Test;

/**
 * 单例模式:单例模式是指一个类只有一个实例，并类自己创建。
 */
public class Main {
    /**
     * 懒汉单例模式测试
     */
    @Test
    public void lazySingletonTest(){
        LazySingleton lazySingleton1 =LazySingleton.getInstance();
        LazySingleton lazySingleton2 =LazySingleton.getInstance();
        System.out.println(lazySingleton1==lazySingleton2?"拿到了同一个懒加载对象":"拿到了不同的懒加载对象");
    }
    /**
     * 懒汉单例模式测试
     */
    @Test
    public void lazySingInitTest(){
        LazySingleInit lazySingleInit1 =LazySingleInit.getInstance();
        LazySingleInit lazySingleInit2 =LazySingleInit.getInstance();
        System.out.println(lazySingleInit1==lazySingleInit2?"拿到了同一个懒加载对象":"拿到了不同的懒加载对象");
    }

    /**
     * 饿汉单利模式测试
     */
    @Test
    public void hungrySingletonTest(){
        HungrySingleton hungrySingleton = HungrySingleton.getInstance();
        HungrySingleton hungrySingleton1 = HungrySingleton.getInstance();
        System.out.println(hungrySingleton==hungrySingleton1?"拿到了同一个饥饿加载对象":"拿到了不同的饥饿加载对象");
    }

}