设计模式：单例模式 易懂易记

 

目录

1、饿汉式

2、懒汉式

3、懒汉式，获取方法加同步锁

4、懒汉式，双检查模式

5、静态内部类实现单例

6、枚举单例

---

1、饿汉式

/**
 * 饿汉式
 * 随着类加载便初始化了，基于类加载器，避免的多线程问题，如果不使用这个类会造成资源浪费，占用内存
 */

public class SingletonHungry {
    private static SingletonHungry instacne = new SingletonHungry();
    private SingletonHungry(){

    }
    public static SingletonHungry getInstacne() {
        return instacne;
    }
}

2、懒汉式

/**
 * 懒汉式
 *
 * 用户第一次调用初始化，节约资源，不用不初始化，在多线程模式下失效
 *
 *
 */

public class SingletonLazy {
    private static SingletonLazy instacne;
    private SingletonLazy(){

    }
    public static SingletonLazy getInstacne() {
        if(instacne == null) {
            instacne =  new SingletonLazy();
        }
        return instacne;
    }
}

3、懒汉式，获取方法加同步锁

/**
 * 懒汉式，获取方法加同步锁
 *
 * 为了解决多线程并发问题，这里在获取单例方法前加上了同步，这样在每次获取的时候都需要进行同步，在高并发下这种开销是巨大的
 * 而且大多数情况下我们并不会用到同步，量级太重，因此这种方式基本不建议使用
 *
 *
 */

public class SingletonLazySyn {
    private static SingletonLazySyn instacne;
    private SingletonLazySyn(){

    }
    public static synchronized SingletonLazySyn getInstacne() {
        if(instacne == null) {
            instacne =  new SingletonLazySyn();
        }
        return instacne;
    }
}

4、懒汉式，双检查模式

/**
 * 懒汉式，双检查模式
 *
 * 双重检查，第一次空是为了解决不必要的同步问题，只有在实例为空的情况下才回去检查，第二次判空是为了实例为空时才创建实例
 *
 * volatile修饰的变量在使用时都会先刷新，也就是将其他线程的工作内存中的数据先同步回主内存，对于执行引擎看不到不一致
 * 情况，所以对于多线程来说，不存在不一致问题，是一种轻量级的同步机制
 * volatile可以防止指令重排序优化
 *
 * volatile变量的运算在并发下并一样不安全
 *
 */

public class SingletonLazyDCL {
    private static volatile SingletonLazyDCL instacne;
    private SingletonLazyDCL(){

    }
    public static  SingletonLazyDCL getInstacne() {
        if(instacne == null) {
            synchronized(SingletonLazyDCL.class) {
                if(instacne == null) {
                    instacne =  new SingletonLazyDCL();
                }
            }
        }
        return instacne;
    }
}

 

5、静态内部类实现单例

/**
 * 静态内部类实现单例
 * 静态内部类实现单例模式，第一次SingletonStaticInner被加载的时候不会初始化sInstance，只有当getInstance第一次
 * 被调用的时候java虚拟机才会加载SingletonHolder
 *
 * 一个内部类并不会在其外部类被虚拟机加载的时候被同时加载
 * 这种方式保证了懒加载的特性，又保证了多线程并发的问题
 */

public class Singleton {

    private Singleton(){

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


    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

6、枚举单例

/**
 * 枚举单例
 *
 * 默认枚举的实例创建是线程安全的，并且在任何情况下都是单例。
 */

public enum SingletonEnum {
    INSTANCE;
    public void doSomeThing() {

    }
}