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

Activity

1. Moosphan

   added

   underwaythe daily question is solving nowthe daily question is solving now

   on Mar 25, 2019
2. DaveBoy commented on Mar 25, 2019

   

   DaveBoy

   on Mar 25, 2019

   More actions

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

   👍React with 👍3Reacted by Luufly_M, Yihaoer and sunchengjian
3. ADrunkenLiBai commented on Mar 25, 2019

   

   ADrunkenLiBai

   on Mar 25, 2019

   More actions

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

   👍React with 👍1Reacted by jinwawa
4. manondidi commented on Mar 25, 2019

   

   manondidi

   on Mar 25, 2019

   Last edited by manondidi

   More actions

   单例分为懒汉模式和恶汉模式
   懒汉模式有线程安全和非线程安全的区别
   实现线程安全的懒汉模式有多重 其中一种是加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的时候判断不过,从而保证了多线程下 单例模式的线程安全,
   另外要慎用单例模式,因为单例模式一旦初始化后 只有进程退出才有可能被回收,如果一个对象不经常被使用,尽量不要使用单例,否则为了几次使用,一直让单例存在占用内存

   👍React with 👍7Reacted by Hulk Su, Chen-keeplearn, gsc19970804, 汪振华, susion, Rickon and Kysop

   👎React with 👎2Reacted by ranjiexu and mufaith
5. FeatherHunter commented on Mar 25, 2019

   

   FeatherHunter

   on Mar 25, 2019

   Collaborator

   More actions

   借助类加载机制，可以在不使用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对象。从而实现单例。

   👍React with 👍12Reacted by Hulk Su, KenStive, 叫我小泡泡_, acer-xhy, ChenLeizheng, LqhlQh, 周豪侠, RedDargon, Kysop, chen3441251 and 2 more

   🎉React with 🎉1Reacted by senlinxuefeng
6. Ssuiyingsen commented on Mar 26, 2019

   

   Ssuiyingsen

   on Mar 26, 2019

   Last edited by Moosphan

   More actions

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

   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;
   }
7. Moosphan

   added

   finished

   and removed

   underwaythe daily question is solving nowthe daily question is solving now

   on Mar 27, 2019
8. Moosphan

   added

   设计模式

   and removed

   finished

   on Apr 11, 2019
9. zhangyalei1 commented on Apr 24, 2019

   

   zhangyalei1

   on Apr 24, 2019

   More actions

   借助类加载机制，可以在不使用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对象。从而实现单例。

   这种也行吗？有没有优缺点,哪位同学呢个讲一下吗
10. Moosphan commented on Apr 24, 2019

    

    Moosphan

    on Apr 24, 2019

    OwnerAuthor

    More actions

    借助类加载机制，可以在不使用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:
11. scsfwgy commented on Apr 25, 2019

    

    scsfwgy

    on Apr 25, 2019

    More actions

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

    👍React with 👍1Reacted by Hulk Su
12. 947635060 commented on Apr 28, 2019

    

    947635060

    on Apr 28, 2019

    More actions

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

    单例模式，主要用于某些环境下对象的唯一性，分为线程安全和不安全。
    上面已经说了
13. ArtarisCN commented on Apr 28, 2019

    

    ArtarisCN

    on Apr 28, 2019

    More actions

    • 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;
    }
    
14. scsfwgy commented on Apr 29, 2019

    

    scsfwgy

    on Apr 29, 2019

    More actions

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

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

    同样的，定义一个类里面全部用静态方法和静态属性同样可以实现... 如果太局限于“标准答案”，面试官稍微延伸一点就会答不上来。。。
15. ddssingsong commented on Apr 30, 2019

    

    ddssingsong

    on Apr 30, 2019

    More actions

    其实，了解下单例模式的历史，以及每种单例模式要解决的核心问题，那么这个问题就能串到一起了

    来来，继续回答问题三段式

    1. 为什么要使用单例

       这个问题搞的我很方啊

       其实我觉得使用单例完全是场景需要，用不用可以体现一个系统的好不好

    2. 单例的发展历程

       1. 饿汉式

          这个东西是线程安全的，早期代码就这写完全没问题

          public class Singleton {
          
              private static Singleton instance = new Singleton();
              
              public static Singleton getInstance() {
                  return instance;
              }
              private Singleton(){
              }
          }

       2. 懒汉式

          突然有一天，有人发现，这个单例一直没用过，但是这个东西还是一直占用我的内存，于是就有了下面的代码

          // 不要再使用这个方式了
          private Singleton(){
              }
              private static Singleton instance ;
          
              public static Singleton getInstance() {
                 if(instance == null){
                     instance = new Singleton();
                 }
                  return instance;
              }

       3. 双重线程锁

          过了一段时间，有人发现在线程中使用懒汉式有问题，对象被创建了多次，为了解决创建多个的问题，就有了synchronized加锁模式，而这个加锁会导致创建变慢，就有了双重检验锁模式，刚开始没啥问题，突然有一天，他们遇到了一个无法重现的问题，Singleton又被创建了多次，程序员方了。

          经过了多方努力，最后找到了问题

          java虚拟机中创建对象需要三个分子步骤，哪三个步骤？我也不知道，这个三个步骤是乱序执行的，有可能会出现对象还没创建成功，但是程序认为他创建成功了，
          
          好吧，就因为这个问题就JDK1.5之后引入了volatile关键字，保证对象的创建步骤是顺序执行的
          
          

          很长一段时间，我们都是使用这个DCL模式

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

          4. 静态内部类单例

             这种单例为何会横空出世，我也很费解，官方的解释是延迟了单例对象的加载时机。

             我觉得这种单例会被引用进来有三点原因

             1. 好写
             2. 巧妙利用了类加载机制保证线程安全
             3. 这种单例更装逼

             public class SingleTon{
               private SingleTon(){}
              
               private static class SingleTonHoler{
                  private static SingleTon INSTANCE = new SingleTon();
              }
              
               public static SingleTon getInstance(){
                 return SingleTonHoler.INSTANCE;
               }

          5. 枚举类单例

             突然有一天，我们有个需求是这样的，我们需要把单例序列化放到文件中去，当我从文件中取出来时，我还想用的是存进去的那个单例

             哎呀，这个问题搞得我又方了

             这时候，枚举类单例横空出世，你把这个单例序列化下存到文件再取出来试试喽

               private static enum Singleton{
                     INSTANCE;
                     
                     private EnumSingleton singleton;
                     //JVM会保证此方法绝对只调用一次
                     private Singleton(){
                         singleton = new EnumSingleton();
                     }
                     public EnumSingleton getInstance(){
                         return singleton;
                     }
                 }
             }

    3. 我们最终选择了那种方式

       我一般就用这个静态内部类单例模式，我就觉得这个比其他的都厉害，你能拿我咋样
       

    👍React with 👍29Reacted by Sunhulg, Luufly_M, Chen-keeplearn, Hulk Su, acer-xhy, 王静波, Meteor-G, 亨利屋, VitoWen, Louisyong9527 and 19 more

    😄React with 😄5Reacted by mm, JHFreedom, dong, han and senlinxuefeng

    😕React with 😕3Reacted by Louisyong9527, han and senlinxuefeng
16. ddssingsong commented on Apr 30, 2019

    

    ddssingsong

    on Apr 30, 2019

    More actions

    对了，Android系统中还有一种单例模式，叫啥来着，HashMap实现的单例

           public class SingletonManager {
               private static Map<String, Object> objMap = new HashMap<>();
               private SingletonManager() {
               }
               public static void putObject(String key, String instance){
                   if(!objMap.containsKey(key)){
                       objMap.put(key, instance);
                   }
               }
               public static Object getObject(String key){
                   return objMap.get(key);
               }
           }
           ```
    
    
    别介意，纯手打

    👍React with 👍3Reacted by Hulk Su, xiaolan and AndroidXinDong
17. RedDargon commented on May 8, 2019

    

    RedDargon

    on May 8, 2019

    More actions

    有些实例需要在整个环境中以单例的形式存在，或者多次创建需要耗费很大资源。所以需要设定单例模式来保证他的唯一性。

    1.懒汉式 
    2.饿汉式
    3.饿汉式+双重非空判断加同步锁+volatile 
    4.静态内部类 
    5.枚举
    6.像系统保存一些manager 比如TelephonyManager 就是通过map容器来保证单例。
    
    推荐第四种
    
18. xianfeng92 commented on May 17, 2019

    

    xianfeng92

    on May 17, 2019

    More actions

    • 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;
    }
    

    synchronized 能保证每次只有一个线程访问代码块，即　instance　实例创建的原子性，volatile 保证了 instance 对多个线程的内存可见性。
19. run-forrest commented on May 23, 2019

    

    run-forrest

    on May 23, 2019

    More actions

    借助类加载机制，可以在不使用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对象。从而实现单例。

    其实吹毛求疵来说，这种是使用了synchronized，详见ClassLoader 类加载机制，loadClass有使用到synchronized。如果非要说不使用synchronized的话，可以参考下CAS，不过客户端开发我觉得基本没必要。
20. guaiguai2015 commented on Jul 23, 2019

    

    guaiguai2015

    on Jul 23, 2019

    More actions

    借助类加载机制，可以在不使用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对象。从而实现单例。

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

    https://blog.csdn.net/mnb65482/article/details/80458571
    这个链接里很好的说明了一些单例模式的优缺点以及回答了你的问题
21. pengxurui commented on Aug 5, 2019

    

    pengxurui

    on Aug 5, 2019

    Last edited by pengxurui

    More actions

    世人都只知道应用级别的单例，如果你能说出线程级别的单例，会加分哦！
    1、ThreadLocal可以很方便地实现线程级别单例
    2、Map<Long,WeakReference>：put(threadId,弱引用）
22. hy20160705 commented on Aug 8, 2019

    

    hy20160705

    on Aug 8, 2019

    More actions

    单列模式

    • 基本实现思路

    1. 将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；
    2. 在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

    • 注意事项

    1. 单例模式在多线程的应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

    • 单列模式的额八种写法

    1. 饿汉式（静态常量）[可用]

    public class Singleton {
    
        private final static Singleton INSTANCE = new Singleton();
    
        private Singleton(){}
    
        public static Singleton getInstance(){
            return INSTANCE;
        }
    }
    

    优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

    缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

    2. 饿汉式（静态代码块）[可用]

    public class Singleton {
    
        private static Singleton instance;
    
        static {
            instance = new Singleton();
        }
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            return instance;
        }
    }
    

    这种方式和上面的方式一样，只不过将类实例化的过程放入了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例，优缺点一样。

    3. 懒汉式(线程不安全)[不可用]

    public class Singleton {
    
        private static Singleton singleton;
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    }
    

    这种写法起到了Lazy Loading的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

    4. 懒汉式(线程安全，同步方法)[不推荐用]

    public class Singleton {
    
        private static Singleton singleton;
    
        private Singleton() {}
    
        public static synchronized Singleton getInstance() {
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    }
    

    解决上面第三种实现方式的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。

    缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

    5. 懒汉式(线程安全，同步代码块)[不可用]

    public class Singleton {
    
        private static Singleton singleton;
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    singleton = new Singleton();
                }
            }
            return singleton;
        }
    }
    

    由于第四种实现方式同步效率太低，所以摒弃同步方法，改为同步产生实例化的的代码块。但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

    6. 双重检查[推荐用]

    public class Singleton {
    
        private static volatile Singleton singleton;
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }
    

    Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

    优点：线程安全；延迟加载；效率较高。

    7. 静态内部类[推荐用]

    public class Singleton {
    
        private Singleton() {}
    
        private static class SingletonInstance {
            private static final Singleton INSTANCE = new Singleton();
        }
    
        public static Singleton getInstance() {
            return SingletonInstance.INSTANCE;
        }
    }
    

    这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

    类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

    优点：避免了线程不安全，延迟加载，效率高。

    8. 枚举[推荐用]

    public enum Singleton {
        INSTANCE;
        public void whateverMethod() {
    
        }
    }
    

    借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。可能是因为枚举在JDK1.5中才添加，所以在实际项目开发中，很少见人这么写过。

    优点:系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

    缺点:当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他开发人员造成困扰，特别是看不到源码的时候。

    适用场合:需要频繁的进行创建和销毁的对象；创建对象时耗时过多或耗费资源过多，但又经常用到的对象；工具类对象；频繁访问数据库或文件的对象

    👍React with 👍4Reacted by zhaoyujie, Hulk Su, Kysop and pressureKai
23. siren4 commented on Aug 15, 2019

    

    siren4

    on Aug 15, 2019

    More actions

    优点：
    节省资源，线程安全.

    缺点：
    生命周期长，容易造成内存泄漏.
24. shenyuexin commented on Aug 22, 2019

    

    shenyuexin

    on Aug 22, 2019

    More actions

    对了，Android系统中还有一种单例模式，叫啥来着，HashMap实现的单例

           public class SingletonManager {
               private static Map<String, Object> objMap = new HashMap<>();
               private SingletonManager() {
               }
               public static void putObject(String key, String instance){
                   if(!objMap.containsKey(key)){
                       objMap.put(key, instance);
                   }
               }
               public static Object getObject(String key){
                   return objMap.get(key);
               }
           }
           ```
    
    
    别介意，纯手打

    HashMap的函数是非同步的，不是线程安全的，这样没问题吗？
25. zywudev commented on Dec 2, 2019

    

    zywudev

    on Dec 2, 2019

    More actions

    自己总结的：https://mp.weixin.qq.com/s/VUf-NP9W9Bb89OdgnyhY7w
26. huazidev commented on Jun 1, 2020

    

    huazidev

    on Jun 1, 2020

    More actions

    什么是单例？
    单例是一种设计模式，单例是整个系统中只能出现类的一个实例，即一个类只有一个对象。 单例模式的解决的痛点就是节约资源，减少内存开销。

    设计单例主要考虑到确保一个实例，线程安全，提高效率，代码简洁几方面。

    实现方式？

    • 懒汉式
    • 饿汉式
    • 双重校验锁（注意 volatile 关键性）
    • 静态内部类
    • 枚举

    双重校验锁方式如果提到 volatile 可以问下 volatile 变量？

    1. 这个变量不会在多个线程中存在复本，直接从内存读取。
    2. 这个关键字会禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。

    你推荐哪种方式？为什么？
    个人推荐使用枚举，简单实用，线程安全，防止通过反射调用私有构造方法。

    还能想到单例的其他问题吗？

    • 序列化问题，如果单例实现了序列化功能，反序列化就会导致出现多个实例 ，解决方式，实现Serializable 接口的 readResolve() 方法
    • 单例可以继承吗？为什么？
      不可以，因为构造方法私有化