单例模式应用场景举例：
“曾经沧海难为水，除却巫山不是云”，这句话用现在的语言解释就是“你是我的唯一”。
GG和MM都是初次恋爱，都把对方视为自己此生的唯一。而且GG和MM都在不断的向对方学习，不断的完善自己。GG和MM的甜蜜和幸福很快就轰动了整个院系。男生一般都拿GG的女朋友教育自己的女朋友说别人怎么怎么样，而女生也经常拿MM的男朋友说男生该如何如何做。而且，年级辅导员还在年级会上表扬了GG和MM，说男生都应该想MM的男朋友学习，女生都应该向GG的女朋友学习！呵呵，很显然，大家都知道，辅导员说GG的女朋友就是指MM，而说MM的男朋友时就是指GG。
单例模式解释：
GoF对单例模式(Singleton Pattern)的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。
单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
英文定义为：Ensure a class only has one instance, and provide a global point of access to it.
单例模式的UML图：
单例模式比较的单纯，其UML图如下所示：
单例模式深入分析：
单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
单例模式适合于一个类只有一个实例的情况，比如窗口管理器，打印缓冲池和文件系统，它们都是原型的例子。典型的情况是，那些对象的类型被遍及一个软件系统的不同对象访问，因此需要一个全局的访问指针，这便是众所周知的单例模式的应用。当然这只有在你确信你不再需要任何多于一个的实例的情况下
在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler， 以避免两个打印作业同时输出到打印机中。每台计算机可以有若干传真卡，但是只应该有一个软件负责管理传真卡，以避免出现两份传真作业同时传到传真卡中的情况。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。
需要管理的资源也包括软件内部资源，譬如，大多数的软件都有一个（甚至多个）属性（properties）文件存放系统配置。这样的系统应当由一个对象来管理一个属性文件。
需要管理的软件内部资源也包括譬如负责记录网站来访人数的部件，记录软件系统内部事件、出错信息的部件，或是对系统的表现进行检查的部件等。这些部件都必须集中管理。
单例模式使用场景分析及代码实现：
在上面的使用场景中，无论是谁叫GG的女朋友，大家都知道只的是MM；而相应的，无论是谁说MM的男朋友，大家都知道是GG。GG和MM分别都是对方单例O(∩_∩)O哈哈~
UML模型图如下所示：
笔者在这里以MM的男朋友GG为例进行单例模式的说明。
GG单例模式的第一个版本，采用的是“饿汉式”，也就是当类加载进来的就立即实例化GG对象，但是这种方式比较的消耗计算机资源。具体实现代码如下：
1 package com.diermeng.designPattern.Singleton; 2 3 /* 4 5 * GG单例模式的第一个版本 为“饿汉式” 6 7 */ 8 9 public class GGVersionOne { 10 11 //在类被加载进入内存的时候就创建单一的GG对象 12 13 public static final GGVersionOne gGVersionOne = new GGVersionOne(); 14 15 //名称属性 16 17 private String name; 18 19 20 21 22 23 public String getName() { 24 25 return name; 26 27 } 28 29 30 31 public void setName(String name) { 32 33 this.name = name; 34 35 } 36 37 38 39 //构造函数私有化 40 41 private GGVersionOne() { 42 43 } 44 45 46 47 //提供一个全局的静态方法 48 49 public static GGVersionOne getGG() { 50 51 return gGVersionOne; 52 53 } 54 55 }
GG单例模式的第二个版本：“懒汉式”，在单线程下能够非常好的工作，但是在多线程下存在线程安全问题，具体代码如下：
1 package com.diermeng.designPattern.Singleton; 2 3 /* 4 5 * GG单例模式的第二个版本 采用“懒汉式” 在需要使用的时候才实例化GG 6 7 */ 8 9 public class GGVersionTwo { 10 11 //GG的姓名 12 13 private String name; 14 15 //对单例本身引用的名称 16 17 private static GGVersionTwo gGVersionTwo; 18 19 20 21 public String getName() { 22 23 return name; 24 25 } 26 27 28 29 public void setName(String name) { 30 31 this.name = name; 32 33 } 34 35 36 37 //构造函数私有化 38 39 private GGVersionTwo() { 40 41 } 42 43 44 45 //提供一个全局的静态方法 46 47 public static GGVersionTwo getGG() { 48 49 if(gGVersionTwo == null) { 50 51 gGVersionTwo = new GGVersionTwo(); 52 53 } 54 55 return gGVersionTwo; 56 57 } 58 59 }
GG单例模式的第三个版本，为解决多线程问题，采用了对函数进行同步的方式，但是比较浪费资源，因为每次都要进行同步检查，而实际中真正需要检查只是第一次实例化的时候，具体代码如下所示：
1 package com.diermeng.designPattern.Singleton; 2 3 /* 4 5 * GG单例模式的第三个版本 对函数进行同步 6 7 */ 8 9 public class GGVersionThree { 10 11 //GG的姓名 12 13 private String name; 14 15 //对单例本身引用的名称 16 17 private static GGVersionThree gGVersionThree; 18 19 20 21 public String getName() { 22 23 return name; 24 25 } 26 27 28 29 public void setName(String name) { 30 31 this.name = name; 32 33 } 34 35 36 37 //构造函数私有化 38 39 private GGVersionThree() { 40 41 } 42 43 44 45 //提供一个全局的静态方法，使用同步方法 46 47 public static synchronized GGVersionThree getGG() { 48 49 if(gGVersionThree == null) { 50 51 gGVersionThree = new GGVersionThree(); 52 53 } 54 55 return gGVersionThree; 56 57 } 58 59 }
GG单例模式第四个版本，既解决了“懒汉式的”多线程问题，又解决了资源浪费的现象，看上去是一种不错的选择，具体代码如下所示：
1 package com.diermeng.designPattern.Singleton; 2 3 /* 4 5 * GG单例模式的第四个版本，既解决了“懒汉式的”多线程问题，又解决了资源浪费的现象，看上去是一种不错的选择 6 7 */ 8 9 public class GGVersionFour { 10 11 //GG的姓名 12 13 private String name; 14 15 //对单例本身引用的名称 16 17 private static GGVersionFour gGVersionFour; 18 19 20 21 public String getName() { 22 23 return name; 24 25 } 26 27 28 29 public void setName(String name) { 30 31 this.name = name; 32 33 } 34 35 36 37 //构造函数私有化 38 39 private GGVersionFour() { 40 41 } 42 43 44 45 //提供一个全局的静态方法 46 47 public static GGVersionFour getGG() { 48 49 if(gGVersionFour == null) { 50 51 synchronized (GGVersionFour.class) { 52 53 if(gGVersionFour == null) { 54 55 gGVersionFour = new GGVersionFour(); 56 57 } 58 59 } 60 61 62 63 } 64 65 return gGVersionFour; 66 67 } 68 69 }
最后我们建立测试客户端测试一下版本四：
1 package com.diermeng.designPattern.Singleton.client; 2 3 import com.diermeng.designPattern.Singleton.GGVersionFour; 4 5 6 7 /* 8 9 * 测试客户端 10 11 */ 12 13 public class SingletonTest { 14 15 public static void main(String[] args) { 16 17 //实例化 18 19 GGVersionFour gG1 = GGVersionFour.getGG(); 20 21 GGVersionFour gG2 = GGVersionFour.getGG(); 22 23 //设值 24 25 gG1.setName("GGAlias"); 26 27 gG2.setName("GG"); 28 29 30 31 System.out.println(gG1.getName()); 32 33 System.out.println(gG2.getName()); 34 35 36 37 38 39 } 40 41 }
输出的结果如下：
1 GG 2 3 GG
单例模式的优缺点分析：
优点：客户端使用单例模式类的实例的时候，只需要调用一个单一的方法即可生成一个唯一的实例，有利于节约资源。
缺点：首先单例模式很难实现序列化，这就导致采用单例模式的类很难被持久化，当然也很难通过网络传输；其次由于单例采用静态方法，无法在继承结构中使用。最后如果在分布式集群的环境中存在多个Java虚拟机的情况下，具体确定哪个单例在运行也是很困难的事情。
单例模式的实际应用简介：
单例模式一般会出现在以下情况下：
在多个线程之间，比如servlet环境，共享同一个资源或者操作同一个对象
在整个程序空间使用全局变量，共享资源
大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。
温馨提示：
细心的读者可能会发现，笔者在写单例模式的双重检查方式的使用了“看上去是一种不错的选择”之语，之所以样说，是因为：Java的线程工作顺序是不确定的，这就会导致在多线程的情况没有实例化就使用的现象，进而导致程序崩溃。不过双重检查在C语言中并没有问题。因为大师说：双重检查对Java语言并不是成立的。尽管如此，双重检查仍然不失为解决多线程情况下单例模式的一种理想的方案。