转自：http://www.cnblogs.com/whgw/archive/2011/10/05/2199535.html
概念：
java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
单例模式有一下特点：
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。
首先看一个经典的单例实现。
public class Singleton {
private static Singleton uniqueInstance = null;
private Singleton() {
// Exists only to defeat instantiation.
}
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
// Other methods...
}
Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）
但 是以上实现没有考虑线程安全问题。所谓线程安全是指：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结 果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。或者说：一个类或者程序所提供的接口对于线程来说是原子操作或者 多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。显然以上实现并不满足线程安全的要求，在并发环境下很可能出现多个Singleton实例。
1 public class TestStream {
2 private String name;
3 public String getName() {
4 return name;
5 }
6 public void setName(String name) {
7 this.name = name;
8 }
9 //该类只能有一个实例
10 private TestStream(){} //私有无参构造方法
11 //该类必须自行创建
12 //有2种方式
13 /*private static final TestStream ts=new TestStream();*/
14 private static TestStream ts1=null;
15 //这个类必须自动向整个系统提供这个实例对象
16 public static TestStream getTest(){
17 if(ts1==null){
18 ts1=new TestStream();
19 }
20 return ts1;
21 }
22 public void getInfo(){
23 System.out.println("output message "+name);
24 }
25 }
1 public class TestMain {
2 public static void main(String [] args){
3 TestStream s=TestStream.getTest();
4 s.setName("张孝祥");
5 System.out.println(s.getName());
6 TestStream s1=TestStream.getTest();
7 s1.setName("张孝祥");
8 System.out.println(s1.getName());
9 s.getInfo();
10 s1.getInfo();
11 if(s==s1){
12 System.out.println("创建的是同一个实例");
13 }else if(s!=s1){
14 System.out.println("创建的不是同一个实例");
15 }else{
16 System.out.println("application error");
17 }
18 }
19 }
运行结果：
张孝祥
张孝祥
output message 张孝祥
output message 张孝祥
创建的是同一个实例
结论：由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点，不管它实现何种功能，整个应用程序都会同享一个实例对象。
1.饿汉式单例类
1 //饿汉式单例类.在类初始化时，已经自行实例化
2 public class Singleton1 {
3 //私有的默认构造子
4 private Singleton1() {}
5 //已经自行实例化
6 private static final Singleton1 single = new Singleton1();
7 //静态工厂方法
8 public static Singleton1 getInstance() {
9 return single;
10 }
11 }
2.懒汉式单例类
1 //懒汉式单例类.在第一次调用的时候实例化
2 public class Singleton2 {
3 //私有的默认构造子
4 private Singleton2() {}
5 //注意，这里没有final
6 private static Singleton2 single=null;
7 //静态工厂方法
8 public synchronized static Singleton2 getInstance() {
9 if (single == null) {
10 single = new Singleton2();
11 }
12 return single;
13 }
14 }
3.登记式单例类
1 import java.util.HashMap;
2 import java.util.Map;
3 //登记式单例类.
4 //类似Spring里面的方法，将类名注册，下次从里面直接获取。
5 public class Singleton3 {
6 private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
7 static{
8 Singleton3 single = new Singleton3();
9 map.put(single.getClass().getName(), single);
10 }
11 //保护的默认构造子
12 protected Singleton3(){}
13 //静态工厂方法,返还此类惟一的实例
14 public static Singleton3 getInstance(String name) {
15 if(name == null) {
16 name = Singleton3.class.getName();
17 System.out.println("name == null"+"--->name="+name);
18 }
19 if(map.get(name) == null) {
20 try {
21 map.put(name, (Singleton3) Class.forName(name).newInstance());
22 } catch (InstantiationException e) {
23 e.printStackTrace();
24 } catch (IllegalAccessException e) {
25 e.printStackTrace();
26 } catch (ClassNotFoundException e) {
27 e.printStackTrace();
28 }
29 }
30 return map.get(name);
31 }
32 //一个示意性的商业方法
33 public String about() {
34 return "Hello, I am RegSingleton.";
35 }
36 public static void main(String[] args) {
37 Singleton3 single3 = Singleton3.getInstance(null);
38 System.out.println(single3.about());
39 }
40 }
应用：
比如：程序员定义的一个读取配置文件的工具类。在项目中可能多次使用这个类，如果每次都new一个实例出来，这样在运行期间就会存在很多实例，
而实际上只需要一个实例对象就可以了。多出来的实例对象会浪费内存资源。
1)内存上有切只有一个实例:
学过尚学堂后有个毛病,总是爱从内存上剖析问题.我查看设计模式文档时上面说过:” Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在”.就是说在在内存中,对于Singleton下的类,内存中永远不可能存在2份或2份以上的实例!!这个在Spring中也有验证”Singleton模式中所谓的对象范围是指在每一个ClassLoader中指定class创建的实例有且仅有一个”.
2)不应有非常量的私有变量:
我们知道了在内存中, Singleton模式的类有切只有一份.那就意味着你对给类的任何操作(方法的的使用,属性的操作等)其实都是对内存中那个唯一实例的操作!!因而可以说Singleton对于项目来说是具有全局性,唯一性的.这让我们想到了什么---静态的类.所以说对于静态类的要求就基本上适用于Singleton类.因而Singleton类不应该有非常量的私有变量(详细:不是说不能有,是不应有.由于只有这一份实例,因而对其的操作都会改变这唯一的实例,因而非常容易造成线程的不安全,即使静态的变量也不是安全的,因而如有变量最好是常量,当然也有访问量统计这让的全局性变量的需求,那这个变量最好是静态的,而且方法要具有排它性---synchronized).
3)在项目中他应该只负责功能问题,而非存储数据:
这个比较好理解,对于Spring来说Dao是单例模式.他只是连接数据库并查阅信息来反馈给用户接受,这是由于Dao没有私有变量,且在内存有且仅有一份,因而无法使用Dao本身来存储反馈回来的值,而只能选择其他含有大量私有变量,且在内存中可以有大量实例存在的类接受---如下面所说的Pojo类!!Pojo类在内存中有很多实例,因为他不是单例模式,这使的他可以有很多的私有变量来在内存中存储类型一致却内容不同的数据!!因而由于单例模式的特性,他在项目的工作不应是存储数据,而是解决某种功能性的需求!!
4)模式单例与Spring单例区别:
这个是我在看Spring文档时才发现的.“Singleton模式中所谓的对象范围是指在每一个ClassLoader中指定class创建的实例有且仅有一个。把Spring的singleton作用域描述成一个container对应一个bean实例最为贴切”就是说模式的单例是真正的单例,他在内存上只有一个,你不能掰出第二个来.而Spring是在Spring管理中的bean是单例,在Spring管理之外你可以new出一个新的来,而且在内存上是不同的对象.这个拿Jsf的配置最能体现.Jsf也是单例模式不过他是更窄的单例.对话式的单例:当一个对话(session)练到服务器时,Jsf会自动的生成这个对话的对象实例.不过在这个对话里这个实例是唯一!因而对于另一个对话它也有唯一的实例.因而可以说实例有很多.但对于一个会话你只拥有其中的一个!!