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修饰的实例，并将一直使用下去而不发生改变，因此其是线程安全的，也没有什么性能开销。

转载于:https://my.oschina.net/u/3676895/blog/1531288