做java开发的可以看看，Java单例模式的8种写法总结！

单例：Singleton，是指仅仅被实例化一次的类。

一、饿汉设计模式

public class SingletonHungry {
    private final static SingletonHungry INSTANCE = new SingletonHungry();

    private SingletonHungry() {
    }

    public static SingletonHungry getInstance() {
        return INSTANCE;
    }
}

因为单例对象一开始就初始化了，不会出现线程安全的问题。

PS：因为我们只需要初始化1次，所以给INSTANCE加了final关键字，表明初始化1次后不再允许初始化。

二、简单懒汉设计模式

由于饿汉模式一开始就初始化好了，但如果一直没有被使用到的话，是会浪费珍贵的内存资源的，所以引出了懒汉模式。

懒汉：首次使用时才会去实例化对象。

public class SingletonLazy1 {
    private static SingletonLazy1 instance;

    private SingletonLazy1() {
    }

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

测试：

public class Main {
    public static void main(String[] args) {
        SingletonLazy1 instance1 = SingletonLazy1.getInstance();
        SingletonLazy1 instance2 = SingletonLazy1.getInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

测试结果：从结果可以看出，打印出来的两个实例对象地址是一样的，所以认为是只创建了一个对象。

三、进阶1：解决多线程并发问题

上述代码存在的问题：在多线程环境下，不能保证只创建一个实例，我们进行问题的重现：

public class Main {
    public static void main(String[] args) {
        new Thread(()-> System.out.println(SingletonLazy1.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy1.getInstance())).start();
    }
}

结果：获取到的对象不一样，这并不是我们的预期结果。

解决方案：

public class SingletonLazy2 {
    private static SingletonLazy2 instance;

    private SingletonLazy2() {
    }
    //在方法加synchronized修饰符
    public static synchronized SingletonLazy2 getInstance() {
        if (instance == null) {
            instance = new SingletonLazy2();
        }
        return instance;
    }
}

测试：

public class Main2 {
    public static void main(String[] args) {
        new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
    }
}

结果：多线程环境下获取到的是同个对象。

四、进阶2：缩小方法锁粒度

上一方案虽然解决了多线程问题，但由于synchronized关键字是加在方法上的，锁粒度很大，当有上万甚至更多的线程同时访问时，都被拦在了方法外，大大降低了程序性能，所以我们要适当缩小锁粒度，控制锁的范围在代码块上。

public class SingletonLazy3 {
    private static SingletonLazy3 instance;

    private SingletonLazy3() {
    }

    public static SingletonLazy3 getInstance() {
        //代码块1：不要在if外加锁，不然和锁方法没什么区别
        if (instance == null) {
            //代码块2:加锁,将方法锁改为锁代码块
            synchronized (SingletonLazy3.class) {
                //代码块3
                instance = new SingletonLazy3();
            }
        }
        return instance;
    }
}

测试：

public class Main3 {
    public static void main(String[] args) {
        new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
    }
}

我们看一下运行结果：还是出现了线程安全的问题（每次执行都可能打印不同的地址情况，只要证明是非线程安全的即可）。

原因分析：当线程A拿到锁进入到代码块3并且还没有创建完实例时，线程B是有机会到达代码块2的，此时线程C和D可能在代码块1，当线程A执行完之后释放锁并返回对象1，线程B进入进入代码块3，又创建了新的对象2覆盖对象1并返回，最后当线程C和D在进行判null时发现instance非空，直接返回最后创建的对象2。

五、进阶3：双重检查锁DCL(Double-Checked-Locking)

所谓双重检查锁，就是在线程获取到锁之后再对实例进行第2次判空检查，判断是不是有上一个线程已经进行了实例化，有的话直接返回即可，否则进行实例初始化。

public class SingletonLazy4DCL {
    private static SingletonLazy4DCL instance;

    private SingletonLazy4DCL() {
    }

    public static SingletonLazy4DCL getInstance() {
        //代码块1：第一次判空检查
        if (instance == null) {
            //代码块2:加锁,将方法锁改为锁代码块
            synchronized (SingletonLazy3.class) {
                //代码块3:进行第二次(双重)判空检查
                if (instance == null) {
                    instance = new SingletonLazy4DCL();
                }
            }
        }
        return instance;
    }
}

测试：

public class Main4DCL {
    public static void main(String[] args) {
        new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
    }
}

六、进阶4：禁止指令重排

在对象的实例过程中，大概可分为以下3个步骤：

分配对象内存空间
在空间中创建对象
实例指向分配到的内存空间地址

由于实例化对象的过程不是原子性的，且JVM本身对Java代码指令有重排的操作，可能1-2-3的操作被重新排序成了1-3-2，这样就会导致在3执行完之后还没来得及创建对象时，其他线程先读取到了未初始化的对象instance并提前返回，在使用的时候会出现NPE空指针异常。

解决：给instance加volatile关键字表明禁止指令重排，出现的概率不大，但这是更安全的一种做法。

public class SingletonLazy5Volatile {
    //加volatile关键字
    private volatile static SingletonLazy5Volatile instance;

    private SingletonLazy5Volatile() {
    }

    public static SingletonLazy5Volatile getInstance() {
        //代码块1
        if (instance == null) {
            //代码块2:加锁,将方法锁改为锁代码块
            synchronized (SingletonLazy3.class) {
                //代码块3
                if (instance == null) {
                    instance = new SingletonLazy5Volatile();
                }
            }
        }
        return instance;
    }
}

七、进阶5：静态内部类

我们还可以使用静态类的静态变量被第一次访问时才会进行初始化的特性来进行懒加载初始化。把外部类的单例对象放到静态内部类的静态成员变量里进行初始化。

public class SingletonLazy6InnerStaticClass {
    private SingletonLazy6InnerStaticClass() {
    }

    public static SingletonLazy6InnerStaticClass getInstance() {
        return SingletonLazy6InnerStaticClass.InnerStaticClass.instance;
        //或者写成return InnerStaticClass.instance;
    }

    private static class InnerStaticClass {
        private static final SingletonLazy6InnerStaticClass instance = new SingletonLazy6InnerStaticClass();
    }
}

虽然静态内部类里的写法和饿汉模式很像，但它却不是在外部类加载时就初始化了，而是在第一次被访问到时才会进行初始化的操作（即getInstance方法被调用时），也就起到了懒加载的效果，并且它可以保证线程安全。

测试：

public class Main6InnerStatic {
    public static void main(String[] args) {
        new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
        new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
    }
}

反射攻击

虽然我们一开始都对构造器进行了私有化处理，但Java本身的反射机制却还是可以将private访问权限改为可访问，依旧可以创建出新的实例对象，这里以饿汉模式举例说明：

public class MainReflectAttack {
    public static void main(String[] args) {
        try {
            SingletonHungry normal1 = SingletonHungry.getInstance();
            SingletonHungry normal2 = SingletonHungry.getInstance();
            //开始反射创建实例
            Constructor<SingletonHungry> reflect = SingletonHungry.class.getDeclaredConstructor(null);
            reflect.setAccessible(true);
            SingletonHungry attack = reflect.newInstance();

            System.out.println("正常静态方法调用获取到的对象：");
            System.out.println(normal1);
            System.out.println(normal2);
            System.out.println("反射获取到的对象：");
            System.out.println(attack);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

八、枚举单例（推荐使用）

public enum SingletonEnum {
    INSTANCE;
}

枚举是最简洁、线程安全、不会被反射创建实例的单例实现，《Effective Java》中也表明了这种写法是最佳的单例实现模式。

单元素的枚举类型经常成为实现Singleton的最佳方法。 --《Effective Java》

为什么说不会被反射创建对象呢？查阅构造器反射实例化对象方法newInstance的源码可知：反射禁止了枚举对象的实例化，也就防止了反射攻击，不用自己在构造器实现复杂的重复实例化逻辑了。

测试：

public class MainEnum {
    public static void main(String[] args) {
        SingletonEnum instance1 = SingletonEnum.INSTANCE;
        SingletonEnum instance2 = SingletonEnum.INSTANCE;
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

总结：几种实现方式的优缺点

懒汉模式

优点：节省内存。
缺点：存在线程安全问题，若要保证线程安全，则写法复杂。

饿汉模式

优点：线程安全。
缺点：如果单例对象一直没被使用，则会浪费内存空间。

静态内部类

优点：懒加载并避免了多线程问题，写法相比于懒汉模式更简单。
缺点：需要多创建一个内部类。

枚举

优点：简洁、天生线程安全、不可反射创建实例。
缺点：暂无

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 216,163评论 6赞 498
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,301评论 3赞 392
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 162,089评论 0赞 352
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,093评论 1赞 292
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,110评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,079评论 1赞 295
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,005评论 3赞 417
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,840评论 0赞 273
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,278评论 1赞 310
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,497评论 2赞 332
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,667评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,394评论 5赞 343
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,980评论 3赞 325
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,628评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,796评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,649评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,548评论 2赞 352