转载

深入探索Java设计模式之单例模式

单例模式可确保在给定的时间实例中只能创建一个具有全局访问点的对象。这是面向对象编程中最常用的技术之一。尽管它很简单，但从类设计的角度来看可能是最简单的，但是在尝试实现它们之前，必须先解决一些细微的问题。本文是在学习完优锐课JAVA架构VIP课程—【框架源码专题】中《学习源码中的优秀设计模式》后写下的学习感悟。通过引用Java代码示例来深入探索这种模式。

总览

在某些情况下，系统应在给定的时间点仅允许一个类的对象存储在内存中。这意味着，当程序实例化该对象时，不应允许该程序创建该类的其他对象。例如，在连接到数据库的系统中，仅使用一个对象来管理数据库连接。这样可以确保其他对象无法初始化不必要的连接，从而由于多个实例化而使系统的整体性能下降。通过创建多个JDBC连接并观察性能，可以很容易地对其进行测试。性能肯定会受到影响或显着降低。单例模式实质上可以保证系统仅创建一个类的实例。

单例模式

使用单例模式是确保给定类实例化一个且只有一个对象的一种标准技术。这是“四人帮”讨论的二十四个设计模式之一。想法是解决诸如实例化类的单个实例，访问类的唯一实例或控制类实例化过程的问题。实现此目的的关键技术是通过使用私有修饰符隐藏构造函数，并提供一种应用检查和验证的方法，以确保仅创建该类的一个实例。

这很简单，但有效地满足了需求。实际上，通过应用相同的原理，我们可以控制创建类的实例的确切数目，而不仅限于单个实例。但是，这里我们仅关注单个实例。

使用单例模式

不难发现实际上我们只需要一个类的一个实例在内存中的情况。多个对象可能会破坏原因或对正在运行的应用程序的性能造成破坏。在面向对象的编程中，正在运行的应用程序通常在内存中具有许多对象，它们在执行过程中相互作用并扮演着至关重要的角色。但是，在实现线程池，高速缓存，对话框或负责首选项和注册表设置的对象时，数据库连接，日志记录，充当外围设备或图形卡设备驱动程序的对象等都是我们想要的情况。对象运行的单个实例；否则，它将产生很多问题，例如资源阻塞，内存过载以及许多其他不一致的行为。这正是我们需要确定适合于实现单例模式的类并进行相应设计的地方。

实现单例模式

这是该模式的快速实现。

 1 public final class Singleton {
 2    private static final Singleton singleInstance =
 3       new Singleton();
 4    private Singleton(){
 5    }
 6    public static Singleton getInstance(){
 7       return singleInstance;
 8    }
 9 }
10  
11 public class TestSingleton {
12    public static void main(String[] args){
13       Singleton s1;
14       Singleton s2;
15       s1 = Singleton.getInstance();
16       s2 = Singleton.getInstance();
17       if(s1 == s2){
18          System.out.println("References to same
19             Singleton object");
20       }
21    }
22 }

Singleton类被声明为final，因此无法创建任何子类。这甚至限制了多重实例化，即使通过对该类进行子类化。构造函数被声明为私有；结果，只有Singleton类可以使用此构造函数创建Singleton对象。对Singleton对象的静态引用将调用私有构造函数，并仅提供该类的一个实例。调用 getInstance() 方法时，仅接收对象的参考副本。

在这里，我们通过创建另一个称为TestSingleton的类来使用一个简单的测试。此类声明两个参考Singleton对象，并调用 getInstance() 方法。然后，我们比较这两个引用，以确保它们实际上引用的是同一运行时实例，而不是两个不同的对象。

有时，我们需要一个仅在第一个静态方法被调用时才创建实例的实现，而不是在此之前。在前面的示例中，对象是静态创建的； getInstance() 方法的作用是简单地返回引用。在这种情况下，我们希望在首次调用时创建对象，称为延迟初始化。另外，我们希望调用是线程安全的；否则，可能导致奇怪的不稳定行为或内存泄漏，从而导致JVM崩溃。这是实现此目的的示例。

 1 public final class Singleton {
 2    private static volatile Singleton singleInstance =
 3       null;
 4    private Singleton(){
 5    }
 6    public static Singleton getInstance(){
 7       if (singleInstance == null) {
 8          synchronized(Singleton.class) {
 9             if (singleInstance == null) {
10                singleInstance = new Singleton();
11             }
12          }
13       }
14       return singleInstance;
15    }
16 }
17  
18 public class TestSingleton {
19    public static void main(String[] args){
20       Singleton s1;
21       Singleton s2;
22       s1 = Singleton.getInstance();
23       s2 = Singleton.getInstance();
24       if(s1 == s2){
25          System.out.println("References to same
26             Singleton object");
27       }
28    }
29 }

也可以使用Enum实现单例。实际上，在可能的情况下，最好使用Enum代替类来实现单例模式。JVM保证从单例Enum中只能创建一个实例。

 1 public enum SingletonEnum {
 2    SINGLEINSTANCE;
 3    public void someMethod(){
 4       // ...
 5    }
 6 }
 7  
 8 public class TestSingleton {
 9    public static void main(String[] args){
10       SingletonEnum s1;
11       SingletonEnum s2;
12       s1 = SingletonEnum.SINGLEINSTANCE;
13       s2 = SingletonEnum.SINGLEINSTANCE;
14       if (s1 == s2){
15          System.out.println("References to same
16             Singleton object");
17       }
18    }
19 }

结论

与往常一样，用户的自由裁量权是良好设计的关键，因为不当使用单例模式可能会导致其他问题。如果单例执行复杂且重量级的操作，则很难对其进行测试。更好的建议是使用依赖项注入框架来构造单个对象。在诸如在GUI应用程序中创建对话框或很少有并发用户的情况下，单例效果最佳。单例模式虽然有用，但在大型可扩展应用程序中造成性能瓶颈方面臭名昭著。

感谢阅读！欢迎留言。想更深入探讨学习也欢迎私信我。下篇继续~

原文 http://www.cnblogs.com/youruike-/p/12058312.html

正文到此结束