JAVA之单例模式

单例模式确保摸个类只有一个实例 ，并且自行实例化并向整个系统提供这个实例。

单例模式的特点：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

单例分为饿汉式 和懒汉式：

饿汉式： 是一个形象的称谓，既然饿，那么就急着 创建类的实例 ，典型的以 空间换时间，在类的初始化时就创建该类的实例。

懒汉式： 既然懒，那么就不急着创建，等到 要用的时候再将 实例创建出来。

public class HungrySingleton {
    private static HungrySingleton instance = new HungrySingleton();

    /**
     * 私有默认构造子
     */
    private HungrySingleton() {
    }

    /**
     * 静态工厂方法
     */
    public static HungrySingleton getInstance() {
        return instance;
    }
}

在懒汉式的使用时，为了避免线程安全问题，我们一般会 加上一个锁。加锁会降低程序的运行效率，为了解决这个问题。我们一般选择使用双层判断来解决。进入的时候判断是否存在类的实例，不存在才加锁。

public class LazySingleton {
    private volatile static LazySingleton instance = null;

    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        // 先检查实例是否存在，如果不存在才进入下面的同步块
        if (instance == null) {
            // 同步块，线程安全的创建实例
            synchronized (LazySingleton.class) {
                // 再次检查实例是否存在，如果不存在才真正的创建实例
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

另外两种实现单例的方式： 详见：http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html

/**类级内部类的方式*/

public class Singleton {

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

    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

/**枚举方式*/
public enum Singleton {
    /**
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。
      */

    uniqueInstance;

    /**
     * 单例可以有自己的操作
      */
    public void singletonOperation(){
        //功能处理
    }
}