Java 单例模式

目录

一、饿汉式

1、通过普通类实现

2、枚举类单例模式

二、懒汉式

1、普通懒汉式

2、双检懒汉式

3、静态内部类实现（推荐）

---

一、饿汉式 1、通过普通类实现

有漏洞的单例模式：

package com.wxl;

import java.io.Serializable;

public class Singleton1 implements Serializable {
    private Singleton1(){
        System.out.println("private Singleton1()");
    }

    private static final Singleton1 INSTANCE=new Singleton1();
    
    public static Singleton1 getINSTANCE(){
        return INSTANCE;
    }
}

测试代码：

package com.wxl;

public class Test {
    public static void main(String[] args) {
        Singleton1 s1=Singleton1.getINSTANCE();
        System.out.println(s1.toString());
        Singleton1 s2=Singleton1.getINSTANCE();
        System.out.println(s2.toString());
    }

}

效果：可以看到hash值一致，的确是单例模式

 上面的代码仍然存在一定的问题，因为使用了Serializable，如果使用反射、反序列化依然可以被修改，再此优化后：

package com.wxl;

import java.io.Serializable;

public class Singleton1 implements Serializable {
    private Singleton1(){
        if(INSTANCE!=null){//应对反射创建对象
            throw new RuntimeException("单例对象不可以重复创建");
        }
        System.out.println("private Singleton1()");
    }

    private static final Singleton1 INSTANCE=new Singleton1();
    
    public static Singleton1 getINSTANCE(){
        return INSTANCE;
    }

    public Object readResolve(){//应对反序列化
        return INSTANCE;
    }
}

即使是这样还是存在一个问题，对于unsafe破解也是无法预防的，目前并没有一个预防unsafe的方法。

2、枚举类单例模式

package com.wxl;

public enum Singleton2 {
    INSTANCE;

    Singleton2(){//枚举类里构造方法默认为private
        System.out.println("private Singleton2()");
    }

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

测试：

public class Test {
    public static void main(String[] args) {
        Singleton2 s1=Singleton2.getInstance();
        System.out.println(s1.toString());
        Singleton2 s2=Singleton2.getInstance();
        System.out.println(s2.toString());
    }

}

 可以看到构造了一次，是单例模式。

对于枚举类来说本省就可以防止反射和反序列化创建新对象，但对于unsafe还是无法预防。

总体来讲，推荐使用枚举类。

二、懒汉式

懒汉式需要考虑创建时线程安全。

1、普通懒汉式

package com.wxl;

import java.io.Serializable;

public class Singleton3 implements Serializable {
    private static Singleton3 INSTANCE=null;

    private Singleton3(){
        System.out.println("private Singleton3");
    }

    //synchronized排队机制，相当于锁，避免多线程环境下的问题
    public static synchronized Singleton3 getInstance(){
        if(INSTANCE==null){
            INSTANCE=new Singleton3();
        }
        return INSTANCE;
    }
}

这种模式下由于加了并发锁，对于性能有很大的影响。

由此优化出了一下实现方式：DCL

2、双检懒汉式

package com.wxl;

import java.io.Serializable;

public class Singleton4 implements Serializable {
    private static volatile Singleton4 INSTANCE=null;//volatile 可见性，有序性

    private Singleton4(){
        System.out.println("private Singleton4");
    }

    public static Singleton4 getInstance(){
        if(INSTANCE==null){
            synchronized (Singleton4.class){//只需要在创建并发时控制即可
                if(INSTANCE==null){
                    INSTANCE=new Singleton4();
                }
            }
        }
        return INSTANCE;
    }
}

优化后基本不会影响性能，而且多线程安全。

3、静态内部类实现（推荐）

通过静态内部类来实现：不仅保证线程安全，而且又有懒汉的特点（推荐使用）

package com.wxl;

import java.io.Serializable;

public class Singleton5 implements Serializable {

    private Singleton5(){
        System.out.println("private Singleton5");
    }
    
    private static class Holder{
        static Singleton5 INSTANCE=new Singleton5();
    }
    
    public static Singleton5 getInstance(){
        return Holder.INSTANCE;
    }
}