设计模式1(单例模式)

概念：
　　Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。
　 单例模式有以下特点：

  在现实生活中存在着有这样的特点的一些类：

         A．这些类只能有一个实例；

         B．这些能够自动实例化；

         C．这个类对整个系统可见，即必须向整个系统提供这个实例。

不妨举一个具体的单例模式的例子：比如教室里面的教师和学生都是需要在黑板上写字的，但是一般的情况下，教室里面应该只有一个黑板吧，它是教师和学生公用滴。这时就要想办法保证取得的黑板是一个共享的唯一的对象。而单例模式就是解决这类问题的一个已经成型的模式。

一、懒汉式单例

1. //懒汉式单例类.加上同步锁   
2. public class Singleton {  
3.     private Singleton() {}  
4.     private static Singleton single=null;  
5.     //静态工厂方法   
6.     public static Singleton getInstance() {  
7.          if (single == null) {    
8.              single = new Singleton();  
9.          }    
10.         return single;  
11.     } 
    
12. } 
    

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

1、在getInstance方法上加同步

1. //懒汉式单例类.加同步   
2. public class Singleton1 {  
3.     private Singleton1() {}  
4.     private static final Singleton1 single = null    
5.     public static synchronizedSingleton1 getInstance() {  
6.     if(single==nbull){
7.         single=new Singleton1();
8.     }  
9.     else{
10.      return single;  
11. }
12. } 
    

2、双重检查锁定

1. public static Singleton getInstance() {  
2.         if (singleton == null) {    
3.             synchronized (Singleton.class) {    
4.                if (singleton == null) {    
5.                   singleton = new Singleton();   
6.                }    
7.             }    
8.         }    
9.         return singleton;   
10.     } 
    

3、静态内部类

1. public class Singleton {    
2.     private static class LazyHolder {    
3.        private static final Singleton INSTANCE = new Singleton();    
4.     }    
5.     private Singleton (){}    
6.     public static final Singleton getInstance() {    
7.        return LazyHolder.INSTANCE;    
8.     }    
9. }   
   

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

注：synchronized关键词不理解的可参考http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html

这里只做简单介绍：

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线对该 object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.

二、饿汉式单例

1. //饿汉式单例类.在类初始化时，已经自行实例化   
2. public class Singleton1 {  
3.     private Singleton1() {}  
4.     private static final Singleton1 single = new Singleton1();  
5.     //静态工厂方法   
6.     public static Singleton1 getInstance() {  
7.         return single;  
8.     }  
9. } 
   

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

饿汉式与懒汉式的区别：
     1、饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。
     2、懒汉式：当程序第一次访问单件模式实例时才进行创建。
       如何选择：如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。
      反之如果单件模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。