单例模式

单例模式分为两种：懒汉式和饿汉式，先看下懒汉式的实现:

public class Singleton {   
    /**  
     * 定义一个变量来存储创建好的类实例  
     */   
    private static Singleton uniqueInstance = null;   
    /**  
     * 私有化构造方法，好在内部控制创建实例的数目  
     */   
    private Singleton(){   
        //   
    }   
    /**  
     * 定义一个方法来为客户端提供类实例  
     * @return 一个Singleton的实例  
     */   
    public static synchronized Singleton getInstance(){   
        //判断存储实例的变量是否有值   
        if(uniqueInstance == null){   
            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量   
            uniqueInstance = new Singleton();   
        }   
        //如果有值，那就直接使用   
        return uniqueInstance;   
    }   
}

再来看下饿汉式的实现:

public class Singleton {   
    /**  
     * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次  
     */   
    private static Singleton uniqueInstance = new Singleton();   
    /**  
     * 私有化构造方法，好在内部控制创建实例的数目  
     */   
    private Singleton(){   
        //   
    }   
    /**  
     * 定义一个方法来为客户端提供类实例  
     * @return 一个Singleton的实例  
     */   
    public static Singleton getInstance(){   
        //直接使用已经创建好的实例   
        return uniqueInstance;   
    }   
}

单例模式的使用范围:

•     目前Java里面实现的单例是一个ClassLoader及其子ClassLoader的范围。因为一个ClassLoader在装载饿汉式实现的单例类的时候就会创建一个类的实例。
•    
•     如果一个虚拟机里面有很多个ClassLoader，这些ClassLoader都装载某个类的话，就算这个类是单例，它也会产生很多个实例。
•     如果一个机器上有多个虚拟机，每个虚拟机里面都应该至少有一个这个类的实例，整个机器上就有很多个实例。
• 另外，这里讨论的单例模式并不适用于集群环境。

   


单例模式的使用范围:
    目前Java里面实现的单例是一个ClassLoader及其子ClassLoader的范围。因为一个ClassLoader在装载饿汉式实现的单例类的时候就会创建一个类的实例。
   
    如果一个虚拟机里面有很多个ClassLoader，这些ClassLoader都装载某个类的话，就算这个类是单例，它也会产生很多个实例。
    如果一个机器上有多个虚拟机，每个虚拟机里面都应该至少有一个这个类的实例，整个机器上就有很多个实例。
    另外，这里讨论的单例模式并不适用于集群环境，对于集群环境下的单例这里不去讨论，那不属于这里的内容范围。
   
   

这两种设计模式有一些区别，区别如下:

1.
懒汉式是典型的时间换空间，每次获取实例都会进行判断，看是否需要创建实例，浪费时间，如果一直不使用，那就不会创建实例，节约内存空间。

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，然后每次调用的时候，就不需要再判断了，节省了运行时间。


2.
从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如说：有两个线程，一个是线程A，一个是线程B，
它们同时调用getInstance方法，那就可能导致并发问题。饿汉式是线程安全的，因为虚拟机保证了只会装载一次，
在装载类的时候是不会发生并发的。


“饿汉式”实现方式，但是这样一来，会浪费一定空间，因为这种实现方式，会在类装载的时候就初始化对象，不管你需不需要。


改进:
现在有一种方法能够让类装载的时候不去初始化对象，一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。
只要不使用到这个类级内部类，那就不会创建对象实例。从而同时实现延迟加载和线程安全。

public class Singleton {   
    /**  
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例  
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载  
     */   
    private static class SingletonHolder{   
        /**  
         * 静态初始化器，由JVM来保证线程安全  
         */   
        private static Singleton instance = new Singleton();   
    }   
    /**  
     * 私有化构造方法  
     */   
    private Singleton(){   
    }   
    public static  Singleton getInstance(){   
        return SingletonHolder.instance;   
    }   
}