java单例设计模式 习题_java 设计模式之单例模式

单例模式：在一个类的使用过程中，始终只保证有一个实例。即在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。

其特点：

1)、某个类只能有一个实例

2)、该类必须自行创建这个实例

3)、该类必须自行向整个系统提供这个实例

这个模式的应用优势在于：

1、某些类创建比较频繁，对于一些大型的对象，这将是很大的系统开销。

2、省去了new，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

代码实现有如下方式：

/**

*线程不安全

*

* @Description:

* @author Biejh

* @date 2017年9月6日 下午5:28:08

*/

class singleInstance {

private singleInstance() {

}

private static singleInstance single = null;

public singleInstance getInstance() {

if (single == null) {

return new singleInstance();

} else {

return single;

}

}

}

这样的类可以满足基本要求，却是一个毫无线程安全保护的类，如果把它放入多线程的环境下，就会出现问题了，如何解决？我们首先会想到对getInstance方法加synchronized关键字，如下

/**

* 线程不安全,解决方案1

* 同步

* @Description:

* @author Biejh

* @date 2017年9月6日 下午5:28:08

*/

class singleInstance2 {

private singleInstance2() {

}

private static singleInstance2 single = null;

public singleInstance2 getInstance() {

if (single == null) {

synchronized (singleInstance2.class) {

if (single == null) {

return new singleInstance2();

}

}

}

return single;

}

}

/**

* 线程不安全,解决方案2

* 同步

* @Description:

* @author Biejh

* @date 2017年9月6日 下午5:28:08

*/

class singleInstance3 {

private singleInstance3() {

}

private static singleInstance3 single = null;

public synchronized singleInstance3 getInstance() {

if (single == null) {

return new singleInstance3();

}

return single;

}

}

方案2的synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成方案1的将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。但是，这样的情况，还是有可能有问题的，看下面的情况：在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。

/**

* 线程不安全,解决方案3

* 内部类

* @Description:

* @author Biejh

* @date 2017年9月6日 下午5:28:08

*/

public class SingleInstance {

private SingleInstance() {

}

private static class getSinge{

private static final SingleInstance instance4 = new SingleInstance();

}

public static SingleInstance getInstance() {

return getSinge.instance4;

}

}

单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。

/**

* 线程安全

*

* @Description:

* @author Biejh

* @date 2017年9月6日 下午5:29:36

*/

class singleInstance1 {

private singleInstance1() {

}

private static final singleInstance1 single = new singleInstance1();

public singleInstance1 getInstance() {

return single;

}

}

这样在定义类的时候就直接给一个final修饰的实例，并将一直使用下去而不发生改变，因此其是线程安全的，也没有什么性能开销。