设计模式篇/创建型模式-单例设计模式.md · ElonChung/Java-Review

创建型模式 - 单例设计模式

简介

所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类 只能存在一个对象实例，并且该类提供了一个取得其对象的方法

实现单例设计模式的十种方式

饿汉式线程安全的（静态成员）
饿汉式线程安全的（静态代码块）
懒汉式线程不安全的（一次判断）
懒汉式线程不安全的（两次判断）
懒汉式线程安全的（方法加锁）
懒汉式线程安全的（静态代码块加锁）
懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁
懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁+Volatile关键字
静态内部类线程安全的
枚举绝对安全的

饿汉式线程安全的（静态成员）

步骤

创建一个私有对象
私有化构造器
暴漏一个外界访问的方法

代码实现

public class Case01 {

    private static Case01 instance = new Case01();

    private Case01() {
    }

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

优缺点比较

优点
- 这种写法比较简单,就是在类加载的时候就去完成实例化,避免了线程同步的问题
缺点
- 在类装载的时候就完成了实例化,没有达到懒加载的效果,如果从始至终都没有使用过这个实例,那么这个实例就浪费了内存
这种方式基于 classloder机制避免了多线程的同步问题.不过,instance在类加载的时候就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定有其他种方法(或者其他种静态方法)导致类装载,这个时候就没有懒加载的效果
结论:这种单例模式可用,但是可能造成内存浪费

饿汉式线程安全的（静态代码块）

步骤

声明一个私有对象
静态代码块创建对象
私有化构造器
暴漏一个外界访问的方法

代码实现

public class Case02 {
    private static Case02 instance;

    static {
        instance = new Case02();
    }

    private Case02() {

    }

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

优缺点比较

种方式和上面的方式其实类似，只不过将类实例化放在静态代码块，但是需要注意的是，instance的声明必须在静态代码块之前，否则可能会为 null 。
其实也就是在类装载的时候，就执行静态代码块中的代码，初始化类的实例，优缺点和上面是一样的
结论:这种单例模式可用,但是可能会造成 内存的浪费

懒汉式线程不安全的（一次判断）

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case03 {
    private static Case03 instance;

    private Case03() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

优缺点

优点,起到了懒加载的效果,什么时候用什么时候再加载,但是只能再单线程下使用后
缺点:如果在多线程情况下,一个线程进入了if(instance == null)还没有来得及向下进行,而另外一个线程也执行了这个判断语句,这个时候会产生多个实例,所以在多线程情况下不可以使用这种方式
总结:实际开发中不可以使用这种方式

懒汉式线程不安全的（两次判断）

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case04 {
    private static Case04 instance;

    private Case04() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

优缺点

优点：起到了懒加载的效果,什么时候用什么时候再加载,但是只能再单线程下使用后，
缺点：如果在多线程情况下,一个线程进入了if(instance == null)还没有来得及向下进行,而另外一个线程也执行了这个判断语句,这个时候会产生多个实例,所以在多线程情况下不可以使用这种方式，虽然多判断了一次，但是还是会多线程并发访问的问题
总结：实际开发中不可以使用这种方式

懒汉式线程安全的（方法加锁）

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case05 {
    private static Case05 instance;

    private Case05() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

优缺点

优点：起到了懒加载的效果，什么时候用什么时候再加载，因为方法加锁，是线程安全的
缺点：锁所用于方法，范围太大了，影响效率
总结：实际开发中可以使用这种方式，但是又更好的方法

懒汉式线程安全的（静态代码块加锁）

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case06 {
    private static Case06 instance;

    private Case06() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static Case06 getInstance() {
        synchronized (Case06.class) {
            if (instance == null) {
                instance = new Case06();
            }
            return instance;
        }
    }
}

优缺点

优点：起到了懒加载的效果，什么时候用什么时候再加载，因为方法加锁，是线程安全的
缺点：锁所用于代码块。每次进入都要一次加锁判断，范围太大了，影响效率
总结：实际开发中可以使用这种方式，但是又更好的方法

懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case07 {
    private static Case07 instance;

    private Case07() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static Case07 getInstance() {
        if (instance == null) {
            synchronized (Case07.class) {
                if (instance == null) {
                    instance = new Case07();
                }
            }
        }
        return instance;
    }
}

优缺点

优点：起到了懒加载的效果，什么时候用什么时候再加载，因为方法加锁，是线程安全的
缺点：锁所用于代码块。第一次进入都要一次加锁判断，之后进入不需要加锁，但是有可能会出问题
总结：实际开发中可以使用这种方式，但是又更好的方法

懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁+Volatile关键字

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case08 {
    private volatile static Case08 instance;

    private Case08() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static Case08 getInstance() {
        if (instance == null) {
            synchronized (Case08.class) {
                if (instance == null) {
                    instance = new Case08();
                }
            }
        }
        return instance;
    }
}

优缺点

优点：起到了懒加载的效果，什么时候用什么时候再加载，因为方法加锁，是线程安全的
添加了 volatile 关键字修饰，禁止了指令重排序，更安全了一些
缺点：锁所用于代码块。第一次进入都要一次加锁判断，之后进入不需要加锁，但是有可能会出问题
总结：实际开发中使用这种方式

静态内部类线程安全的

步骤

声明一个私有对象
私有化构造器
暴漏一个外界访问的方法在方法里面进行控制判断

代码实现

public class Case09 {
    private Case09() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class Inner {
        private static Case09 instance = new Case09();
    }

    public static Case09 getInstance() {
        return Inner.instance;
    }
}

优缺点

优点：是线程安全的，跟随类加载而加载
缺点：可能会创建了对象不使用，浪费空间

枚举绝对安全的

步骤

枚举类只有一个实例
暴漏一个外界访问的方法

代码实现

public enum Case10{
    INSTANCE;

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

优缺点

缺点：是饿汉式可能浪费空间
优点：绝对安全

总结

单例模式保证了系统内存种只有该类的一个对象,节省了系统资源,对于一些需要频繁创建和销毁的对象,使用单例模式可以提高系统性能
当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
单例模式使用的场景:需要频繁的进行创建和销毁的对象,创建对象的时候消耗过多或耗费资源过多(也就是:重量级对象) 但又是经常用到的对象,工具类对象,频繁访问数据库或文件的对象(比如数据源.session工厂等)
对于非枚举实现的单例设计模式，可以通过反射创建对象，但是一般不会这么做，而枚举类型通过反射创建对象的时候，会抛异常
推荐使用双重检查锁+Volatile关键字

ElonChung / Java-Review

创建型模式 - 单例设计模式

简介

实现单例设计模式的十种方式

饿汉式线程安全的（静态成员）

饿汉式线程安全的（静态代码块）

懒汉式线程不安全的（一次判断）

懒汉式线程不安全的（两次判断）

懒汉式线程安全的（方法加锁）

懒汉式线程安全的（静态代码块加锁）

懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁

懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁+Volatile关键字

静态内部类线程安全的

枚举绝对安全的

总结

简介

发行版

贡献者

近期动态

ElonChung / Java-Review .gitee-modal { width: 500px !important; }

创建型模式 - 单例设计模式

简介

实现单例设计模式的十种方式

饿汉式 线程安全的（静态成员）

饿汉式 线程安全的（静态代码块）

懒汉式 线程不安全的 （一次判断）

懒汉式 线程不安全的 （两次判断）

懒汉式 线程安全的 （方法加锁）

懒汉式 线程安全的 （静态代码块加锁）

懒汉式 线程安全的 （静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁

懒汉式 线程安全的 （静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁+Volatile关键字

静态内部类 线程安全的

枚举 绝对安全的

总结

简介

发行版

贡献者

近期动态

搜索帮助

ElonChung / Java-Review

饿汉式线程安全的（静态成员）

饿汉式线程安全的（静态代码块）

懒汉式线程不安全的（一次判断）

懒汉式线程不安全的（两次判断）

懒汉式线程安全的（方法加锁）

懒汉式线程安全的（静态代码块加锁）

懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁

懒汉式线程安全的（静态代码块加锁 - 缩小静态代码块的区域）线程安全的双重检查锁+Volatile关键字

静态内部类线程安全的

枚举绝对安全的