设计模式--Singleton

        原本对设计模式或者Java设计模式一无所知，也暂时没有准备对设计模式做太深 的了解，但是自从接触Singleton设计模式时，我发现，设计模式原来对工作和设计是很有帮助的...

       Singleton是单独、独身的意思。在Java程序设计中，经常遇到一个类只允许一个实例存在，在很多操作中，比如建立目录、数据库连接都需要这样的单线程操作。同样，减少了对象的个数，也很大程度的节省了内存。

public   class  SingletonClass  ... {
    private SingletonClass()...{
        //default
        }
        private static SingletonClass instance = new SingletonClass();
        //这里提供了一个供外部访问本class的静态方法，可以直接访问　　
    public static SingletonClass getInstance()...{
            return instance;
        }
    public void print()...{
        System.out.println("SingletonClass测试");
    }
}

一个未使用Singleton模式的类：

public   class  UnSingletonClass  ... {
    public UnSingletonClass()...{
        //default
    }
    
}

通过实例化对象可以看出结果：

public   static   void  main(String[] args)  ... {
        // TODO 自动生成方法存根
        //Singleton类SingletonClass产生的两个对象，比较HashCode；
        System.out.println("Singleton类SingletonClass产生的两个对象，比较HashCode");
        SingletonClass instance1 = SingletonClass.getInstance();
        SingletonClass instance2 = SingletonClass.getInstance();
        System.out.println("SingletonClass_1:"+instance1.hashCode());
        System.out.println("SingletonClass_2:"+instance2.hashCode());
        System.out.println("-------------------------------------");
        //非Singleton类UnSingletonClass产生的两个对象，比较HashCode；
        System.out.println("非Singleton类UnSingletonClass产生的两个对象，比较HashCode");
        UnSingletonClass instance3 = new UnSingletonClass();
        UnSingletonClass instance4 = new UnSingletonClass();
        System.out.println("UnSingletonClass_1:"+instance3.hashCode());
        System.out.println("UnSingletonClass_2:"+instance4.hashCode());        
}

控制台结果：
Singleton类SingletonClass产生的两个对象，比较HashCode
SingletonClass_1:7051261
SingletonClass_2:7051261
-------------------------------------
非Singleton类UnSingletonClass产生的两个对象，比较HashCode
UnSingletonClass_1:5383406
UnSingletonClass_2:16164678

        从上面的HashCode就可以看出两个类的使用效果不同了。

        一般Singleton模式通常有几种形式：

public   class  Singleton  ... {

    private Singleton()...{}

　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用

　　private static Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　public static Singleton getInstance() ...{
　　　　return instance; 　　
　　} 
}  

第二种形式：

public   class  Singleton  ... { 
　　 private static Singleton instance = null;
   public static synchronized Singleton getInstance() ...{
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
       　//使用时生成实例！
　         　if (instance==null)
　　　     　instance＝new Singleton();
　　         return instance; 　　

             } 
     }  

第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。一般认为第一种形式要更加安全些。