（4）单例模式

 1 package com.yeepay.sxf.interfaces.impl;
 2 /**
 3  * 饿汉单例模式
 4  * 是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。
 5  * @author sxf
 6  *
 7  */
 8 public class SingObj {
 9     /**
10      * 持有自己的引用
11      */
12     private static SingObj singObj=new SingObj();
13     /**
14      *似有化构造器
15      */
16     private SingObj(){
17         
18     }
19     /**
20      * 提供静态方法返回自身对象
21      * @return
22      */
23     public static SingObj getSingObj(){
24         return singObj;
25     }
26 }

 1 package com.yeepay.sxf.interfaces.impl;
 2 /**
 3  * 懒汉模式
 4  * 
 5  * (1)懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间
 6  * (2)由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式实现呢？
 7  *
 8  */
 9 public class SingObj2 {
10     /**
11      * 持有自身引用
12      */
13     private static SingObj2 singObj2=null;
14     
15     /**
16      * 构造器私有化
17      */
18     private void  SingObj2(){
19         
20     }
21     
22     /**
23      * 提供静态方法返回对象.同步方法，防止出现多个对象，违反单例规则
24      * @return
25      */
26     public static synchronized SingObj2 getSingObj2(){
27         if(singObj2==null){
28             singObj2=new SingObj2();
29         }
30         return singObj2;
31     }
32 }

 1 package com.yeepay.sxf.interfaces.impl;
 2 /**
 3  * 懒汉模式升级版
 4  * 
 5  * @author sxf
 6  *
 7  */
 8 public class SingObj3 {
 9     /**
10      * 持有自身对象的引用
11      */
12     private static SingObj3 singObj3=null;
13     
14     /**
15      * 构造器似有化
16      */
17     private void SingObj3(){
18         
19     }
20     /**
21      * 升级版的静态方法返回单例对象引用。只需要第一次创建时才用到同步。以后获取就不需要同步
22      * @return
23      */
24     public static SingObj3 getSingObje3(){
25         if(singObj3==null){
26             synchronized (SingObj3.class) {
27                 if(singObj3==null){
28                     singObj3=new SingObj3();
29                 }
30             }
31         }
32         
33         return singObj3;
34     }
35 
36 }

 1 package com.yeepay.sxf.interfaces.impl;
 2 /**
 3  * 懒汉模式的再次升级版
 4  * 使用类级内部类
 5  * 什么是类级内部类？
 6  *       （1）简单点说，类级内部类指的是，有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。
 7 　　（2）类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。
 8 　　（3）类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
 9       （4）类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载
10  * 
11  * 多线程缺省同步所的机制
12  * 大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：
13 
14 　　1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时
15 
16 　　2.访问final字段时
17 
18 　　3.在创建线程之前创建对象时
19 
20 　　4.线程可以看见它将要处理的对象时
21  * @author sxf
22  *
23  */
24 public class SingObj4 {
25     /**
26      * 构造器似有化
27      */
28     private SingObj4(){}
29     /**
30      *    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
31      *    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
32      *    一旦加载，不会再次加载
33      */
34     private static class SingletonHolder{
35         /**
36          * 静态初始化器，由JVM来保证线程安全
37          */
38         private static SingObj4 instance = new SingObj4();
39     }
40     /**
41      * 
42      * @return
43      */
44     public static SingObj4 getInstance(){
45         return SingletonHolder.instance;
46     }
47 }

 1 public enum Singleton {
 2     /**
 3      * 定义一个枚举的元素，它就代表了Singleton的一个实例。
 4      */
 5     
 6     uniqueInstance;
 7     
 8     /**
 9      * 单例可以有自己的操作
10      */
11     public void singletonOperation(){
12         //功能处理
13     }
14 }