JAVA设计模式之单例设计模式

        单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

　　在JAVA中实现单例，必须了解JAVA内存机制，JAVA中实例对象存在于堆内存中，若要实现单例，必须满足两个条件：

　　1.限制类实例化对象。即只能产生一个对象。

　　2.保证外部能够获取这个对象，否则对象创建将毫无意义

　　如要满足以上两个条件，可以将构造方法私有化，然后在类中提供一个静态方法获取类实例。代码如下

1 1 public class SingleTon {
2 2 
3 3     private static final SingleTon single = new SingleTon();  
4 4 
5 5     private SingleTon() {
6 6 
7 7     }
8 8 
9 9     /**
1010      * 获取一个单例对象。
1111      * @return 返回SingleTon对象。
1212      */
1313     public static SingleTon getInstance() {
1414         return single;
1515     }
1616 
1717 }

　　JVM加载SingleTon后，会对静态成员做默认初始化，此时new SingleTon()创建的对象会赋值给single，类只会被加载一次，即使多次调用getInstance方法，所返回的对象也不会改变。single字段在初始化的过程中，对象就创建了，所以以上案例的代码又称为饿汉式。从对象的生命周期来看，类一旦加载，对象会在堆中立即创建，会浪费内存空间，因此，又存在另外一种称为懒汉式的单例设计模式。代码如下：

1 1 public class SingleTonLazy {
2 2 
3 3     private static SingleTonLazy single = null;
4 4 
5 5     private SingleTonLazy() {
6 6 
7 7     }
8 8 
9 9     /**
1010      * 获取一个单例对象。
1111      * @return 返回SingleTon对象。
1212      */
1313     public static SingleTonLazy getInstance() {
1414 
1515         if (single == null) {
1616             single = new SingleTonLazy();
1717         }
1818   
1919         return single;
2020 
2121     }
2222 
2323 }

　　SingleTonLazy在被加载进方法区后，不会立即创建对象，而是直到getInstance方法被调用以后，对象才会被创建。这种方式可以节约内存空间，但是也存在着线程安全问题，当线程A执行到判断对象为null，此时线程B获得执行权，线程B判断对象为null，此时线程A重新获得执行权，创建对象，线程B恢复，继续创建对象。将代码修改如下，使用同步锁解决线程安全问题。

1 1 public class SingleTonLazy {
2 2 
3 3     private static SingleTonLazy single = null;
4 4 
5 5     private final static Lock lock = new ReentrantLock();
6 6 
7 7     private SingleTonLazy() {
8 8 
9 9     }
1010 
1111     /**
1212      * 获取一个单例对象。
1313      * @return 返回SingleTon对象。
1414      */
1515     public static SingleTonLazy getInstance() {
1616 
1717         if (single != null) {
1818             return single;
1919         }
2020 
2121         lock.lock();
2222         if (single == null) {
2323             single = new SingleTonLazy();
2424         }
2525         lock.unlock();
2626 
2727         return single;
2828 
2929     }
3030 }

　　总结：饿汉式与懒汉式各有优缺点，但是相对来说，占用内存空间比让cpu判断锁的开销要小，所以饿汉式更使用一些。