单例设计模式

单例模式（Singleton）

简单来说，单例模式就是创建一个类，仅产生一个实例供外部访问。

1.1 实现方案

方案一：

 1 /**
 2  * 单例模式：方案一
 3  */
 4 public class Singleton {
 5 
 6     // 将构造方法私有化，防止以new的方式创建对象并且实例化
 7     private Singleton() {  }
 8 
 9     // 定义一个引用自身对象的属性，该属性为静态常量
10     private static final Singleton instance = new Singleton();
11 
12     /**
13      * 静态方法，返回该类的实例
14      * @return
15      */
16     public static Singleton getInstance() {
17         return instance;
18     }
19 }

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

方案二：

 1 /**
 2  * 单例模式：方案二
 3  */
 4 public class Singleton {
 5 
 6     // 将构造方法私有化，防止以new的方式创建实例
 7     private Singleton() {  }
 8 
 9     // 定义一个自身类型的静态变量
10     private static Singleton instance = null;
11 
12     /**
13      * 静态方法，返回该类的实例
14      * @return
15      */
16     public static Singleton getInstance() {
17         // 判断该实例是否存在
18         if (null == instance)
19             instance = new Singleton();
20         return instance;
21     }
22 }

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

方案三：

 1 /**
 2 
 3  * 单例模式：方案三
 4 
 5  */
 6 
 7 public class Singleton {
 8 
 9     // 将构造方法私有化，防止以new的方式创建实例
10 
11     private Singleton() {  }
12 
13 
14     // 定义一个自身类型的静态变量
15 
16     private static Singleton instance = null;
17 
18     /**
19 
20      * 静态方法，返回该类的实例
21 
22      * 方法添加同步锁，防止多线程访问产生多个实例
23 
24      * @return
25 
26      */
27 
28     public synchronized static Singleton getInstance() {
29 
30         // 判断该实例是否存在
31 
32         if (null == instance)
33 
34             instance = new Singleton();
35 
36         return instance;
37     }
38 }

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

方案四：

 1 /**
 2 
 3  * 单例模式：方案四
 4 
 5  */
 6 
 7 public class Singleton {
 8     // 将构造方法私有化，防止以new的方式创建实例
 9 
10     private Singleton() {  }
11 
12     // 定义一个自身类型的静态变量
13 
14     private static Singleton instance = null;
15 
16     /**
17 
18      * 静态方法，返回该类的实例
19 
20      * 方法内部添加同步块，不用每次调用方法都要获取同步锁
21 
22      * @return
23 
24      */
25 
26     public static Singleton getInstance() {
27 
28         // 判断该实例是否存在
29 
30         if (null == instance) {
31 
32             // 如果不存在，才获取同步锁，如果存在则直接返回对象
33 
34             synchronized(Singleton.class) {
35 
36                 if (null == instance) {
37 
38                     instance = new Singleton();
39 
40                 }
41 
42             }
43 
44         }
45         return instance;
46     }
47 }

方案四改进了方案三，保证只有在必要的情况下，即当对象没有创建的时候才获取同步锁，如果对象已经存在，则直接返回即可，实现了高效并且线程安全。

方案四需要注意同步块中又进行了一次判断，原因是，如果当代码执行到第一次判断时，有可能另一个线程刚好创建了一个实例，因此，获取锁之后还要判断一次。

即：-------------------------------------

1.2 应用举例

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

 1 /**
 2 
 3  * Redis连接池工具
 4 
 5  */
 6 
 7 public class JedisPoolUtil {
 8 
 9     private static volatile JedisPool jedisPool = null;
10 
11     // 提供一个私有构造函数保证单例
12 
13     private JedisPoolUtil() { }
14     /**
15 
16      * 获取一个<tt>JedisPool</tt>
17 
18      * @return jedisPool 一个单例的{JedisPool}
19 
20      */
21 
22     public static JedisPool getJedisPoolInstance() {
23         if (null == jedisPool) {
24             synchronized (JedisPool.class) {
25                 if (null == jedisPool) {
26                     JedisPoolConfig poolConfig = new JedisPoolConfig();
27                     // poo2已经更改maxActive为maxTotal
28                     poolConfig.setMaxTotal(32);
29                     // pool2已经更改为maxWaitMillis
30                     poolConfig.setMaxWaitMillis(100 * 1000);
31                     jedisPool = new JedisPool(poolConfig, "0.0.0.0", 6379);
32                 } // if end
33             } // synchronized end
34         } // if end
35         return jedisPool;
36     }
37     public static void release(JedisPool jedisPool) {
38         Jedis jedis = null;
39         try {
40             jedis = jedisPool.getResource();
41         } finally {
42             if (null != jedis)  jedis.close();
43         }
44     }
45 }