设计模式-单例模式

1、单例模式

饿汉式

缺点：不能懒加载

/**
 * @ClassName:SingletonObject1
 * @Author:linianest
 * @CreateTime:2020/3/21 10:40
 * @version:1.0
 * @Description TODO: 单例设计模式：饿汉式
 */
public class SingletonObject1 {
    private static final SingletonObject1 instance = new SingletonObject1();

    private SingletonObject1() {
        // empty
    }

    public static SingletonObject1 getInstance() {
        return instance;
    }
}

实现了懒加载，但是可能创建多个实例

/**
 * @ClassName:SingletonObject1
 * @Author:linianest
 * @CreateTime:2020/3/21 10:40
 * @version:1.0
 * @Description TODO: 单例设计模式：懒汉式
 */
public class SingletonObject2 {
    private static SingletonObject2 instance;

    private SingletonObject2() {
        // empty
    }
    // TODO 实现了懒加载，但是可能创建多个实例
    public static SingletonObject2 getInstance() {
        if (null == instance)
            instance = new SingletonObject2();
        return SingletonObject2.instance;
    }
}

懒汉式

synchronized同步方法块

缺点：性能不是很好

/**
 * @ClassName:SingletonObject1
 * @Author:linianest
 * @CreateTime:2020/3/21 10:40
 * @version:1.0
 * @Description TODO: 单例设计模式：懒汉式(synchronized)
 */
public class SingletonObject3 {
    private static SingletonObject3 instance;

    private SingletonObject3() {
        // empty
    }
    /**
     * 但是性能慢，串行模式
     * @return
     */
    public synchronized static SingletonObject3 getInstance() {
        if (null == instance)
            instance = new SingletonObject3();
        return SingletonObject3.instance;
    }
}

synchronized同步代码块（double check）

第二种方法：将synchronized同步代码块

优点：

1. 单例模式
2. 懒加载
3. 性能好

缺点：容易空指针异常

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter1
 * @version: 1.0
 */

/**
 * @ClassName:SingletonObject1
 * @Author:linianest
 * @CreateTime:2020/3/21 10:40
 * @version:1.0
 * @Description TODO: 单例设计模式：懒汉式
 */
public class SingletonObject5 {
    private static volatile SingletonObject5 instance;

    private SingletonObject5() {
        // empty
    }

    /**
     * double check
     *
     * @return
     */
    public static SingletonObject5 getInstance() {
        if (null == instance) {
            synchronized (SingletonObject5.class) {
                if (null == instance)
                    instance = new SingletonObject5();
            }
        }
        return SingletonObject5.instance;
    }
}

优雅的方式

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter1
 * @version: 1.0
 */

/**
 * @ClassName:SingletonObject6
 * @Author:linianest
 * @CreateTime:2020/3/21 17:09
 * @version:1.0
 * @Description TODO: 单例模式：优雅的方式
 */
public class SingletonObject6 {

    private SingletonObject6() {
    }

    private static class InstanceHolder {
        private final static SingletonObject6 instance = new SingletonObject6();
    }

    public static SingletonObject6 getInstance() {
        return InstanceHolder.instance;
    }
}

枚举的方式（推荐）

• 枚举是线程安全的
• 构造函数只会装载一次

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter1
 * @version: 1.0
 */

import java.util.stream.IntStream;

/**
 * @ClassName:SingletonObject6
 * @Author:linianest
 * @CreateTime:2020/3/21 17:09
 * @version:1.0
 * @Description TODO: 单例模式(枚举)：优雅的方式
 */
public class SingletonObject7 {

    private SingletonObject7() {
    }

    /**
     * 枚举类型线程安全，构造函数，只会被装载一次
     */
    private enum Singleton {
        INSTANCE;

        private final SingletonObject7 instance;

        Singleton() {
            instance = new SingletonObject7();
        }

        public SingletonObject7 getInstance() {
            return instance;
        }
    }


    public static SingletonObject7 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    public static void main(String[] args) {
        IntStream.rangeClosed(1, 100).forEach(i -> new Thread(String.valueOf(i)) {
            @Override
            public void run() {
                System.out.println(SingletonObject7.getInstance());
            }
        }.start());
    }
}