单例模式总结和应用

单例模式（Singleton）

　　单例模式就是创建类的一种方式，保证该类仅有一个实例，该类可以向外部提供一个其实例的全局访问点。类自身维护实例，可以保证外部随时能够访问，并且能够防止实例化多个对象。
　　
实现单例类的关键：

私有构造器;
自身的私有的静态成员;
公共的静态实例访问方法。

1. 实现方案

方案一

/**
 * 单例模式：方案一
 */
public class Singleton {

    // 将构造方法私有化，防止以new的方式创建实例
    private Singleton() { }

    // 定义一个引用自身对象的属性，该属性为静态常量
    private static final Singleton instance = new Singleton();

    /**
     * 静态方法，返回该类的实例
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

　　该方法较为简单，而且获取的实例是静态常量，因此不存在线程安全问题，完全摒弃了synchronized造成的性能问题。然而，当该类被加载时，就会创建静态常量对象，并且该对象会一直占有内存，直到该类卸载，因此有些情况下会造成内存问题。

方案二

/**
 * 单例模式：方案二
 */
public class Singleton {

    // 将构造方法私有化，防止以new的方式创建实例
    private Singleton() { }

    // 定义一个自身类型的静态变量
    private static Singleton instance = null;

    /**
     * 静态方法，返回该类的实例
     * @return
     */
    public static Singleton getInstance() {
        // 判断该实例是否存在
        if (null == instance)
            instance = new Singleton();
        return instance;
    }
}

　　方案二仅仅是基于内存的节省对方案一的改造，但是如果在多线程环境下，有可能会产生多个实例对象，因此不是线程安全的。

方案三

/**
 * 单例模式：方案三
 */
public class Singleton {

    // 将构造方法私有化，防止以new的方式创建实例
    private Singleton() {  }

    // 定义一个自身类型的静态变量
    private static Singleton instance = null;

    /**
     * 静态方法，返回该类的实例
     * 方法添加同步锁，防止多线程访问产生多个实例
     * @return
     */
    public synchronized static Singleton getInstance() {
        // 判断该实例是否存在
        if (null == instance)
            instance = new Singleton();
        return instance;
    }
}

　　方案三在方案二的基础上为静态方法添加同步锁，以达到线程安全的要求。但是同步方法被频繁调用时，当然会存在效率问题。

方案四

/**
 * 单例模式：方案四
 */
public class Singleton {

    // 将构造方法私有化，防止以new的方式创建实例
    private Singleton() {  }

    // 定义一个自身类型的静态变量
    private static Singleton instance = null;

    /**
     * 静态方法，返回该类的实例
     * 方法内部添加同步块，不用每次调用方法都要获取同步锁
     * @return
     */
    public static Singleton getInstance() {
        // 判断该实例是否存在
        if (null == instance) {
            // 如果不存在，才获取同步锁，如果存在则直接返回对象
            synchronized(Singleton.class) {
                if (null == instance) {
                    instance = new Singleton();
                }
            }
        }

        return instance;
    }
}

　　方案四改进了方案三，保证只有在必要的情况下，即当对象没有创建的时候才获取同步锁，如果对象已经存在，则直接返回即可，实现了高效并且线程安全。
　　方案四需要注意同步块中又进行了一次判断，原因是，如果当代码执行到第一次判断时，有可能另一个线程刚好创建了一个实例，因此，获取锁之后还要判断一次。

２. 应用举例

　　例如，在使用Jedis的时候，由于多线程下频繁使用，因此需要使用连接池来管理多个Jedis连接，而为了保证连接池只有一个，则需要采用单例模式，如果不用Spring来管理连接池，则需要使用单例模式：

/**
 * Redis连接池工具
 */
public class JedisPoolUtil {

    private static volatile JedisPool jedisPool = null;

    // 提供一个私有构造函数保证单例
    private JedisPoolUtil() { }

    /**
     * 获取一个<tt>JedisPool</tt>
     * @return jedisPool 一个单例的{JedisPool}
     */
    public static JedisPool getJedisPoolInstance() {

        if (null == jedisPool) {
            synchronized (JedisPool.class) {
                if (null == jedisPool) {
                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    // poo2已经更改maxActive为maxTotal
                    poolConfig.setMaxTotal(32);
                    // pool2已经更改为maxWaitMillis
                    poolConfig.setMaxWaitMillis(100 * 1000);

                    jedisPool = new JedisPool(poolConfig, "0.0.0.0", 6379);
                } // if end
            } // synchronized end
        } // if end

        return jedisPool;
    }

    public static void release(JedisPool jedisPool) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
        } finally {
            if (null != jedis)  jedis.close();
        }
    }
}