单例模式这几种写法你了解吗？很多朋友在运用单例模式的时候，对于怎么写都有一定的疑惑，那么今天我们来看看单例模式常用的几种写法，一起来了解一下。

前言
设计模式（Design Pattern），提供了在软件开发过程中面临的一些问题的最佳解决方案，是Java开发者必修的一门课程。主要分创建型模式，结构型模式和行为型模式。接下来介绍的单例模式属于创建型模式。

单例模式

单例模式，也就是只有一个实例，并且是自己负责创建自己的对象，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1、懒汉式

懒汉式，就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返回，没有则新建。有线程安全和线程不安全两种写法，区别就是 synchronized 关键字。

public class LHan {

    private static LHan instance;

    private LHan(){}//私有构造方法

    public static LHan getInstance(){
        if(instance==null){
            instance=new LHan();
        }
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

2、饿汉式

饿汉式，“比较勤”，实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。好处就是没有线程安全的问题，坏处是浪费内存空间。

public class EHan {
    
    private static EHan instance=new EHan();//饿汉式
    
    private EHan(){}//私有构造方法
    
    public static EHan getInstance(){
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

3、双检锁

双检锁，又叫双重校验锁，综合了懒汉式和饿汉式两者的优缺点整合而成。在代码实现中，特点是 synchronized 关键字内外都加了一层 if 条件判断，这样既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。

public class DoubleCheck {
    
    private static DoubleCheck instance;
    
    private DoubleCheck(){}
    
    public static DoubleCheck getInstance(){
        if(instance==null){
            synchronized (DoubleCheck.class){
                if(instance==null){
                    instance=new DoubleCheck();
                }
            }
        }
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

4、静态内部类

静态内部类的方式效果类似双检锁，但实现更简单。但这种方式只适用于静态域的情况，双检锁方式可以在实例域需要延迟初始化时使用。

public class Singleton {
    
    private static class SingletonHolder{
        private static  final Singleton INSTANCE=new Singleton();
    }
    private Singleton(){}
    
    public static final Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

5、枚举

枚举的方式是比较少见的一种实现方式，但是看上面的代码实现，却更简洁清晰。并且这种方式还自动支持序列化机制，绝对防止多次实例化。

小结

一般情况下，懒汉式（包含线程安全和线程不安全两种方式）都比较少用；饿汉式和双检锁都可以使用，可以根据具体情况自主选择；在要明确实现 Lazy Loading 效果时，可以考虑静态内部类的实现方式；若涉及到反序列化创建对象时，也可以尝试使用枚举方式。