单例设计模式

什么是单例设计模式？

答：单例设计模式是一种思想，它属于创建型模式。当在一个系统中要求一个类只能有一个实例对象时，要考虑使用单例设计模式，使用单例设计模式设计的类称为单例类。

       单例类有三大特点：

                                1.单例类只能有一个实例；

                                2.单例类必须自己创建自己唯一的实例；

                                3.单例类必须自行向整个系统提供这一实例。

什么情况下会使用单例设计模式？

答：系统中要求一个类只能有一个实例对象时，要考虑使用单例设计模式。

        现实中，一些资源管理器常常被设计成单例模式。比如：每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输入到一台打印机中；每台计算机可以有若干通信端口，但这些通信端口必须由系统集中管理，以避免一个通信端口同时被两个请求同时调用。

       一个类是没有状态的类时，要考虑使用单例设计模式。没有状态的类就是该类只提供工具性函数，而没有属性值。比方说，Spring容器管理的对象默认是单例，为什么要这么设计？Service和Controller层的类都是无状态类，只是为了提供工具性函数，没必要有多个实例，设计成单例可以节约资源。

 

java语言中的单例设计模式？

答：Runtime类。Runtime类提供一个静态工厂方法getRuntime()，public static Runtime getRuntime()；通过调用此方法可以获得Runtime类唯一的一个实例。

       每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。应用程序不能创建自己的 Runtime 类实例。

        Spring容器管理的对象默认都是单例的，这里使用了单例设计模式。

 

单例模式的思想是什么？请写一个代码实现？

答：保证一个系统中一个类只能有一个实例对象。

代码实现：

public class Single{         //构造函数私有化         private Single(){}             //定义静态成员变量         private static Single s = null;              //对外提供公共的访问方法         public static Single getInstance(){                 if(s == null){                         synchronized(Single.class){                                 if(s == null){                                         s = new Single();                                 }                         }                 }                   return s;         } }

 

单例模式优点：

在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。

 

单例模式缺点：

没有抽象层，因此扩展很难。职责过重，在一定程度上违背了单一职责。

 

如何保证类在内存中只有一个对象呢？

A：把构造方法私有化

B：在成员位置自己创建一个对象

C：通过一个公共的方法提供访问

 

单例设计模式分懒汉式和饿汉式两种，如何选择使用哪一种呢？

答：

开发：用饿汉式（是不会出问题的单例模式）

面试：用懒汉式（可能会出问题的单例模式）

A：懒加载（延迟加载）

B：线程安全问题

 

饿汉式单例设计模式

A：把构造方法私有化

B：在成员位置自己创建一个对象

C：通过一个公共的方法提供访问

 

代码：

public class Single{

        private Single(){}

        private static Single s = new Single();

        public static Single getInstance(){

                return s;

        }

}

public class Single{         //构造函数私有化         private Single(){}           //成员变量位置创建对象         //因为静态方法只能访问静态成员变量，加static         //为了不让外界修改这个值，加private         private static Single s = new Single();           //向外界提供一个公共方法，为了外界能够直接访问，加static         public static Single getInstance(){                 return s;         } }

 

懒汉式单例设计模式

 

public class Single{         //构造函数私有化         private Single(){}           //静态成员变量只有一份，可以共享         private static Single s = null;           //向外界提供一个公共方法，为了外界能够直接访问，加static         public static Single getInstance(){                 //第一次访问该方法时，s为null，创建对象                 //之后再访问该方法时，因为s为静态成员变量，可以共享，所有s不为null                 if(s == null){                         s = new Single();                 }                 return s;         } }

 

这时的懒汉式有线程安全问题。解决线程安全问题的方法是加同步，可以同步方法，也可以同步代码块。我们这里用同步代码块。

public class Single{         //构造函数私有化         private Single(){}           //静态成员变量只有一份，可以共享         private static Single s = null;           //向外界提供一个公共方法，为了外界能够直接访问，加static         public static Single getInstance(){                 //第一次访问该方法时，s为null，创建对象                 //之后再访问该方法时，因为s为静态成员变量，可以共享，所有s不为null                 synchronized(Single.class){                         if(s == null){                                 s = new Single();                         }                 }                   return s;         } }

加完锁之后，还有一个问题，就是访问一次getInstance()方法，都要判断一次有没有锁，这样效率就会降低，解决办法：在同步代码块外面加一层判断。（最终版）

 

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

 

面试问：懒汉式和饿汉式有什么不同？

答：饿汉式，在类加载的时候创建对象，没有线程安全问题。

懒汉式，调用方法的时候才会创建对象（延迟加载），有线程安全问题。

 

懒汉式单例模式有线程安全问题，解决办法是加同步，使用的锁是哪一个？

答：该类所属的字节码对象！

 

单例模式的思想是什么？请写一个代码实现？

答：保证类在内存中只有一个对象。

代码实现：

public class Single{         //构造函数私有化         private Single(){}             //定义静态成员变量         private static Single s = null;              //对外提供公共的访问方法         public static Single getInstance(){                 if(s == null){                         synchronized(Single.class){                                 if(s == null){                                         s = new Single();                                 }                         }                 }                   return s;         } }