2019-03-25：请简要谈一谈单例模式？

[Moosphan]

提示：什么是单例模式？实现方式？应用场景？

[DaveBoy]

单例模式，主要用于某些环境下对象的唯一性，分为线程安全和不安全，写法也比较多，但是个人认为只要熟悉主要的几种就行，包括双检查、静态内部类、枚举

[ADrunkenLiBai]

楼上说的很对，对象重复创建消耗资源很大，单例也仅仅是避免对象重复创建，节省内存，避免多个实例存在线程的不安全，存在多个实例对象，业务逻辑就会复杂很多，至于写法就看业务跟个人喜好了，写法很多，楼上已经说了

[manondidi]

单例分为懒汉模式和恶汉模式
懒汉模式有线程安全和非线程安全的区别
实现线程安全的懒汉模式有多重 其中一种是加double check

public class SingletonDoubleCheck {

    private SingletonDoubleCheck() { }

    private static volatile SingletonDoubleCheck instance;//代码1

    public static SingletonDoubleCheck getInc() {
        if (null == instance) {//代码2
            synchronized (SingletonDoubleCheck.class) {
                if (null == instance) {//代码3
                    instance = new SingletonDoubleCheck();//代码4
                }
            }
        }
        return instance;
    }
}

在代码 在多线程中 两个线程可能同时进入代码2, synchronize保证只有一个线程能进入下面的代码,
此时一个线程A进入一个线程B在外等待, 当线程A完成代码3 和代码4之后,
线程B进入synchronized下面的方法, 线程B在代码3的时候判断不过,从而保证了多线程下 单例模式的线程安全,
另外要慎用单例模式,因为单例模式一旦初始化后 只有进程退出才有可能被回收,如果一个对象不经常被使用,尽量不要使用单例,否则为了几次使用,一直让单例存在占用内存

[FeatherHunter]

借助类加载机制，可以在不使用synchronized等内容的情况下，最高效的实现单例。

public class Singleton {
    public static Singleton getInstance(){
        // 1. 调用该方法时，才会访问 LazyHolder.INSTANCE这个静态类的静态变量
        return  LazyHolder.INSTANCE;
    }
    private static class LazyHolder{
        // 2. 访问 LazyHolder.INSTANCE才会触发Singleton的初始化
        static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}
}

1. 参考自类加载规范的：访问静态字段时，才会会初始化静态字段所在的类
2. 因为类初始化是线程安全的，并且只会执行一次。因此在多线程环境下，依然能保证只有一个Singleton实例。
3. 解释：getInstance()调用了LazyHolder的静态字段INSTANCE，所以会触发LazyHolder的加载和初始化。LazyHolder的初始化阶段会对静态字段INSTANCE进行赋值，也就是 new Singleton()，此外初始化阶段是线程安全的且只执行一次，因此就算是多线程，也只会创建一个Singleton对象。从而实现单例。

[Ssuiyingsen]

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例 。
其又分为三种形式
饿汉式，懒汉式，双重锁式

1. 饿汉式

public class Evilman{
    //在自己内部定义自己的一个实例，只供内部调用 不判空直接怼
    private static final Evilman mEvilman= new Evilman();
    private Evilman(){
    }
    //直接访问
    public static EvilmangetInstance(){
        return mEvilman;
    }
}

2. 懒汉式

private static Slacker mSlacker= null;
private Slacker(){}
public static synchronized Slacker getslacker() {
    // 为空就new  
    if (mSlacker== null)
        mSlacker= new Slacker();
    return mSlacker;
}

3. 双重检查

private static Slacker mSlacker= null;
private Slacker(){}
public static Slacker getslacker() {
    // 为空就new  
if(mSlacker== null){
synchronized (Slacker .class) {
    if (mSlacker== null){
         return mSlacker= new Slacker();
      }
    }
}
    return mSlacker;
}

[zhangyalei1]

借助类加载机制，可以在不使用synchronized等内容的情况下，最高效的实现单例。

public class Singleton {
    public static Singleton getInstance(){
        // 1. 调用该方法时，才会访问 LazyHolder.INSTANCE这个静态类的静态变量
        return  LazyHolder.INSTANCE;
    }
    private static class LazyHolder{
        // 2. 访问 LazyHolder.INSTANCE才会触发Singleton的初始化
        static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}
}

1. 参考自类加载规范的：访问静态字段时，才会会初始化静态字段所在的类
2. 因为类初始化是线程安全的，并且只会执行一次。因此在多线程环境下，依然能保证只有一个Singleton实例。
3. 解释：getInstance()调用了LazyHolder的静态字段INSTANCE，所以会触发LazyHolder的加载和初始化。LazyHolder的初始化阶段会对静态字段INSTANCE进行赋值，也就是 new Singleton()，此外初始化阶段是线程安全的且只执行一次，因此就算是多线程，也只会创建一个Singleton对象。从而实现单例。

这种也行吗？有没有优缺点,哪位同学呢个讲一下吗

[Moosphan]

借助类加载机制，可以在不使用synchronized等内容的情况下，最高效的实现单例。

public class Singleton {
    public static Singleton getInstance(){
        // 1. 调用该方法时，才会访问 LazyHolder.INSTANCE这个静态类的静态变量
        return  LazyHolder.INSTANCE;
    }
    private static class LazyHolder{
        // 2. 访问 LazyHolder.INSTANCE才会触发Singleton的初始化
        static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}
}

1. 参考自类加载规范的：访问静态字段时，才会会初始化静态字段所在的类
2. 因为类初始化是线程安全的，并且只会执行一次。因此在多线程环境下，依然能保证只有一个Singleton实例。
3. 解释：getInstance()调用了LazyHolder的静态字段INSTANCE，所以会触发LazyHolder的加载和初始化。LazyHolder的初始化阶段会对静态字段INSTANCE进行赋值，也就是 new Singleton()，此外初始化阶段是线程安全的且只执行一次，因此就算是多线程，也只会创建一个Singleton对象。从而实现单例。

这种也行吗？有没有优缺点,哪位同学呢个讲一下吗

可以参考一下《Android源码设计模式解析与实战》，里面对于单例的实现方式做了比较详细的讲解。:smile:

[scsfwgy]

顺便问一下，无论是单例、多实例、还是静态方法，我们大部分都是在访问”方法“。那么单例和静态方法有什么区别？用单例，我干嘛不把单例里面的方法都定义为静态的，成员变量也定义为静态的？

[947635060]

顺便问一下，无论是单例、多实例、还是静态方法，我们大部分都是在访问”方法“。那么单例和静态方法有什么区别？用单例，我干嘛不把单例里面的方法都定义为静态的，成员变量也定义为静态的？

单例模式，主要用于某些环境下对象的唯一性，分为线程安全和不安全。
上面已经说了

[ArtarisCN]

• DCL
  使用synchronized同步 new 方法，内外加双重判断，volatile 修饰实例。
  synchronized 能保证每次只有一个线程访问代码块，volatile 保证了 instance 创建的原子性。

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    /**
     * 如果实现了Serializable, 必须重写这个方法
     */
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }
}

• 静态内部类

public class Singleton {
    private static Singleton instance;
    /**
     * 私有化构造方法
     */
    private Singleton() {}
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，
     * 而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder {
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static final Singleton INSTANCE = new Singleton();
    }

}

• 枚举
  优点：简单粗暴，线程安全，高效，自动避免序列化/反序列化攻击、反射攻击(枚举类不能通过反射生成)
  缺点：可读性差

public enum Singleton {
    INSTANCE;
}