单例模式详解-优快云博客

定义：单例模式保证在整个软件系统内存中只存在一个类的实例，并且该类只有一个方法可以获取实例。属于创建型设计模式。

注意：必须将该类的构造方法私有化。

单例模式的七种写法：

饿汉式（静态常量）：

/**
 * 使用静态常量的饿汉式单例模式demo
 */
public class EagerSingletonDemo1 {

    private static final EagerSingletonDemo1 INSTANCE = new EagerSingletonDemo1();

    private EagerSingletonDemo1(){

    }

    public static EagerSingletonDemo1 getInstance(){
        return INSTANCE;
    }

}
//优点：线程安全，简单。
//缺点：不属于懒加载，在装载该类时会立即初始化该变量，浪费内存。可以实际使用

饿汉式（静态常量加静态代码块）：

/**
 * 使用静态常量的饿汉式单例模式demo,用静态代码块创建并初始化。
 */
public class EagerSingletonDemo2 {

    private static final EagerSingletonDemo2 INSTANCE;

    private EagerSingletonDemo2(){

    }
    static {
        INSTANCE = new EagerSingletonDemo2();
    }
    public static EagerSingletonDemo2 getInstance(){
        return INSTANCE;
    }

}

//优点：线程安全，简单。
//缺点：不属于懒加载，在装载该类时会立即初始化该变量，浪费内存。可以实际使用

懒汉式（线程不安全）：

/**
 * 懒汉式单例模式线程不安全
 */
public class LazyLoadingSingletonDemo1 {

    private static LazyLoadingSingletonDemo1 INSTANCE;

    private LazyLoadingSingletonDemo1(){

    }

    public static LazyLoadingSingletonDemo1 getInstance(){
        if (INSTANCE == null){
            INSTANCE = new LazyLoadingSingletonDemo1();
        }
        return INSTANCE;
    }
}

//该方式存在线程安全问题，在实际中绝不能使用。

懒汉式（线程安全）

/**
 * 懒汉式单例模式线程安全，方法级同步
 */
public class LazyLoadingSingletonDemo1 {

    private static LazyLoadingSingletonDemo1 INSTANCE;

    private LazyLoadingSingletonDemo1(){

    }

    public static synchronized LazyLoadingSingletonDemo1 getInstance(){
        if (INSTANCE == null){
            INSTANCE = new LazyLoadingSingletonDemo1();
        }
        return INSTANCE;
    }
}

//优点：线程安全，懒加载。
//缺点：每次调用该方法都要进行同步，性能差，不推荐使用。

双重检查懒汉式：

public class DoubleCheckLazyLoadingSingletonDemo {

    //该变量必须用volatile修饰，保证该变量线程可见,保证对单例的初始化立马被其他线程所知晓。
    private volatile static DoubleCheckLazyLoadingSingletonDemo instance;
    private DoubleCheckLazyLoadingSingletonDemo(){

    }
    public static DoubleCheckLazyLoadingSingletonDemo getInstance(){
        if (instance == null){
            synchronized (DoubleCheckLazyLoadingSingletonDemo.class){
                if (instance == null){
                    instance = new DoubleCheckLazyLoadingSingletonDemo();
                }
            }
        }
        return instance;
    }
}
//懒加载，线程安全，只有第一批进去的线程要同步，剩下的不需要同步，性能也好。推荐使用。

使用静态内部类实现单例：

静态内部类的特点：

装载外部类时不会装载静态内部类。
JVM保证类的装载过程线程安全。
只装载一次。

/**
 * 使用静态内部类实现单例模式demo。
 */
public class StaticInnerClassSingletonDemo {
    private StaticInnerClassSingletonDemo(){

    }
    private static class InnerClass{
        private static final StaticInnerClassSingletonDemo instance = new StaticInnerClassSingletonDemo();
    }

    /**
     * 调用这个方法时会装载InnerClass类，初始化实例，并且线程安全，并且只会装载一次。
     * @return
     */
    public static StaticInnerClassSingletonDemo getInstance(){
        return InnerClass.instance;
    }

}
//优点：懒加载，线程安全。推荐使用。

使用枚举方式实现单例：

/**
 * 使用枚举方式实现单例。
 */
public enum SingletonWithEnum {
    INSTANCE(1,2);

    private int a;
    private int b;

    private SingletonWithEnum(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public void SumAB(){
        System.out.println(a+b);
    }
}

//测试通过
public void testSingletonWithEnum(){
        SingletonWithEnum instance = SingletonWithEnum.INSTANCE;
        SingletonWithEnum instance2 = SingletonWithEnum.INSTANCE;
        System.out.println(instance == instance2);
        instance.SumAB();
    }

//线程安全，并且可以防止反序列化创建新对象。