java 设计模式之单例模式
java 设计模式之单例模式
Loveror_ahu 发表于3个月前
java 设计模式之单例模式
  • 发表于 3个月前
  • 阅读 5
  • 收藏 0
  • 点赞 0
  • 评论 0

华为云·免费上云实践>>>   

单例模式:在一个类的使用过程中,始终只保证有一个实例。即在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修饰的实例,并将一直使用下去而不发生改变,因此其是线程安全的,也没有什么性能开销。

共有 人打赏支持
粉丝 2
博文 7
码字总数 6593
×
Loveror_ahu
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: