设计模式之单例模式_new random()有必要单列吗

1、定义

单例模式（Singleton Pattern）：确保某一个类只有一个实例，自行实例化并向整个系统提供这个实例。

2、形式

单例模式分为懒汉式和饿汉式两种，形式如下所述。

饿汉式

通用类图和代码如下所示：

public class Singleton {

    private static final Singleton singleton = new Singleton();

    private Singleton(){}

    public static Singleton getSingleton(){
        return singleton;
    }

    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

饿汉式单例模式是线程安全的，通过将单例对象用static修饰，把实例对象加载到堆中，保证了多个线程访问时的可见性。但该方式的缺点在于应用一加载该实例就会进入堆中，可能会浪费内存。

懒汉式

懒汉式是当应用需要时才加载实例对象，代码如下所示：

public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这种方式虽然性能很好，但带来的显著问题是高并发情况下的线程安全问题。如果一个线程还未产生实例对象，其他线程正好执行到if(singleton == null)的逻辑判断，那么会造成内存中出现多个实例对象！

一个解决线程安全的办法是在getSingleton()方法前加上synchronized关键字，这表明同一时间内只允许一个线程访问，保证了线程安全，但在高并发情况下其他线程必须等待当前线程释放方法锁，极大的影响了系统性能，因此不建议使用。

那么进一步优化，减少锁的粒度，让它在实例的产生处进行并发控制如何？代码如下所示：

public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(singleton == null){
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
            
        }
        return singleton;
    }

    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

很显然这依然会出现线程安全问题，假如一个线程A执行完判断if(singleton == null)后被另一个线程B抢占执行，等B执行完生成实例后，A线程获得执行权依然会生成一个新实例。

再次改进，得到双重检测同步锁机制，代码如下：

public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }

        }
        return singleton;
    }

    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

虽然这种方式看起来十分安全，但很不幸，该机制依然无法保证线程安全，这是由于编译器（JVM）优化中的指令重排机制导致的，详见另一篇博文volatile概念详解及使用场景。

volatile+双重检测机制实现懒汉式单例

public class Singleton {

    private volatile static Singleton singleton = null;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }

        }
        return singleton;
    }

    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

由于volatile的禁止指令重排能力，保证了该单例模式下的线程安全。

枚举类实现懒汉式单例

由于上面的双重检测机制利用了volatile关键字，如果单例模式中存在其他的涉及线程安全问题（例如不是指令重排导致的），或volatile没能有效在JVM中实现（例如在JavaSE5之前），那么上述方式也无法保证线程的安全。一个最为推荐的方式是使用枚举类实现懒汉式单例，由于JVM保证枚举类中的调用方法只调用一次，因此有效的保证类只实例化一次。实现代码如下：

public class SingletonCase {


    private SingletonCase(){}

    public static SingletonCase getSingleton(){
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton{
        INSTANCE;
        
        private SingletonCase singleton;
        
        Singleton(){
			singleton = new SingletonCase();
		}
        public SingletonCase getInstance(){
            return singleton;
        }
    }
    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3、优缺点

优点：

• 由于内存中只有一个实例，故而减少了内存开支
• 当一个对象需要产生比较多的资源（如读取配置、产生其他依赖对象等）时，使用单例模式可以减少系统的性能开销
• 单例模式可以避免对资源的多重占用，例如对于写文件动作，由于只有一个实例在内存中，避免了对同一个资源同时进行写操作
• 单例模式可以在系统设置全局的访问点，优化和共享资源的访问，例如设计一个单例类负责所有数据表的映射处理

缺点：

• 单例模式一般没有接口，难以扩展
• 单例模式对测试不友好，在并行开发的环境下，如果单例模式没有完成，无法进行测试
• 单例模式跟单一职责原则有冲突

注：一个类应该只实现一个逻辑，而不应该关心其是否是单例的，单例与否取决于环境，好的单例模式应当把单例和业务逻辑融合在一个类中。

4、使用场景

• 生成唯一序列号的环境
• 在整个项目中需要一个共享访问点或共享数据，例如Web上的计数器，通过一个单例模式保存计数器的值，并确保是线程安全的。
• 创建一个对象需要消耗的资源过多，比如访问IO或数据库
• 定义大量静态常量和静态方法的环境，例如工具类

注：工具类也可以采用静态类（所有的方法都是静态方法）实现。一般来说，如果是存在配置信息的工具类，一般适合采用单例模式；而如果只是无配置信息的简单工具类，更适合直接采用静态类的方式实现。

5、扩展

多例模式

public class Singletons {

    //最大单例数
    private static int maxNumOfSingleton = 2;
    
    private Singletons(){}

    //单例集合
    private static ArrayList<Singletons> singletonsList = new ArrayList<Singletons>();
    
    //生成实例对象
    static {
        for (int i = 0; i < maxNumOfSingleton; i++) {
            singletonsList.add(new Singletons());
        }
    }

    public static Singletons getInstance(){
        Random random = new Random();
        int i = random.nextInt(maxNumOfSingleton);
        return singletonsList.get(i);
    } 
    
    public static void doSomething(){
        /**
         * 其他业务代码
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

这种产生固定数量对象的模式可以决定在内存中有多少个实例，方便系统进行扩展，以修正单例可能存在的性能问题。例如读取文件，可以通过生成固定数量的reader实例来满足多请求下的快速响应。

6、小结

单例模式是23个模式中较为简单的模式，在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理这些Bean的声明周期。如果采用非单例模式（Prototype类型），则Bean初始化后的管理交由J2EE容器。