单例模式

单例模式是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。

核心知识点如下：

(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

(3) 定义一个静态方法返回该类的实例。

1.饿汉模式

public class Singleton {
    //1.将构造方法私有化，不允许外部直接创建对象
    private Singleton(){        
    }

    //2.创建类的唯一实例，使用private static修饰
    private static Singleton instance=new Singleton();

    //3.提供一个用于获取实例的方法，使用public static修饰
    public static Singleton getInstance(){
        return instance;
    }
}

• 优点是：写起来比较简单，而且不存在多线程同步问题，避免了synchronized所造成的性能问题；
• 缺点是：当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

---

2.懒汉模式

public class Singleton2 {
    //1.将构造方式私有化，不允许外边直接创建对象
    private Singleton2(){
    }

    //2.声明类的唯一实例，使用private static修饰
    private static Singleton2 instance;

    //3.提供一个用于获取实例的方法，使用public static修饰
    public static Singleton2 getInstance(){
        if(instance==null){
            instance=new Singleton2();
        }
        return instance;
    }
}

• 优点是：写起来比较简单，当类SingletonTest被加载的时候，静态变量static的instance未被创建并分配内存空间，当getInstance方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存；
• 缺点是：并发环境下很可能出现多个SingletonTest实例。

---

3.最佳解决

public class SingletonTest { 

    // 定义一个私有构造方法
    private SingletonTest() { 

    }   
    //定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用)
    private static volatile SingletonTest instance;  

    //定义一个共有的静态方法，返回该类型实例
    public static SingletonTest getIstance() { 
        // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率）
        if (instance == null) {
            //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (SingletonTest.class) {
                //未初始化，则初始instance变量
                if (instance == null) {
                    instance = new SingletonTest();   
                }   
            }   
        }   
        return instance;   
    }   
}

---

4.单例模式加载配置文件

/**
 * 单例模式读取Properties属性文件
 *
 * @author huangcongmin
 * @version , 2012-7-29
 * @since
 */
public class PropertiesFactoryHelper {

    /**
     * 私有的属性防止外部引用
     */
    private static PropertiesFactoryHelper _instance = null;
    private Properties properties = new Properties();

    /**
     * 私有的默认构造函数，防止使用构造函数进行实例化
     */
    private PropertiesFactoryHelper() {
        try {
            InputStream inputStream = this.getClass().getResourceAsStream("/jdbc.properties");
            properties.load(inputStream);
            if (inputStream != null)
                inputStream.close();
        } catch (Exception e) {
            System.out.println(e + "file not found");
        }
    }

    /**
     * 单例静态工厂方法，同步防止多线程环境同时执行
     *
     * @author huangcongmin
     * @date 2012-7-29
     * @return
     */
    synchronized public static PropertiesFactoryHelper getInstance() {
        if (_instance == null) {
            _instance = new PropertiesFactoryHelper();
        }
        return _instance;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#clone()
     */
    public PropertiesFactoryHelper clone() {
        return getInstance();
    }

    /**
     * 读取配置信息key - value
     *
     * @author huangcongmin
     * @date 2012-7-29
     * @param key
     * @return
     */
    public String getConfig(String key) {
        return properties.getProperty(key);
    }

}

public class Test {
    public static void main(String[] args) {
        PropertiesFactory propFactory = PropertiesFactory.getInstance();
        System.out.println(propFactory.getConfig("jdbc.url"));
    }
}