设计模式大家一定不陌生,Java语言中我们经常会有意无意的就使用到一些设计模式,那么设计模式到底是什么,为什么要使用设计模式呢?
其实设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。说白了就是整理写法,让代码更系统化,优化代码量,使用更方便。
使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。
设计模式分为很多种,今天先跟大家分享一下最基础常用的一种设计模式——单例设计模式。首先了解下什么是单例设计模式:
它是一种对象创建模式,它用于产生一个对象的具体实例,它可以确保系统中一个类只产生一个实例。
使用单例设计模式有什么好处:
一、对于频繁使用的对象,可以省略创建对象所花费的时间,这对于那些重量级对象而言,是非常可观的一笔系统开销
二、由于new操作的次数减少,因而对系统内存的使用频率也会降低 ,这将减轻GC(垃圾回收器)压力,缩短GC停顿时间。
单例模式严格来说共有6中写法,其中饿汉式与懒汉式是最基本的两种,大家是一定需要掌握的,后面4中也是在这基础上进行优化的,下面我们就先来了解饿汉式:
/**
* 饿汉式
*/
public class HungrySingleton {
//一开始就创建对象
private static final HungrySingleton mHungrySingleton = new HungrySingleton();
//构造方法私有,外部就无法通过构造方法创建对象
private HungrySingleton(){}
//向外部暴露公有的静态方法,返回实例
public static HungrySingleton getInstance(){
return mHungrySingleton;
}
}
可以看到,饿汉式单例设计模式,一开始他就会创建这个类的实例,然后将默认构造方法设为私有的private,这样外部就无法通过构造方法创建对象了,最后它会创建一个公有的、静态的,返回值为类对象本身的getInstance方法,这个方法是暴露给外部使用的。
这样每次外部通过getInstance方法得到的对象就是这个类中一开始就实例化出来的对象,所以叫单例模式。
但是饿汉式存在一个缺点:
无法对Instance实例做延时加载。即它一开始就会直接创建一个对象,即使不使用时,单例仍然会被创建
所以我们能不能对饿汉式进行优化呢?让它可以在我们需要使用这个对象时在创建呢?所以便有了下面这种写法,懒汉式:
/**
* 懒汉式
*/
public class LazySingleton {
//并不直接实例对象
private static LazySingleton mLazySingleton;
//构造方法私有
private LazySingleton() {
}
public static LazySingleton getInstance() {
//第一次调用时会判断这个对象有没有被实例化
if (mLazySingleton == null) {
//为空就实例化
mLazySingleton = new LazySingleton();
}
//不为空说明已经实例化过了,直接返回该对象
return mLazySingleton;
}
}
相比较饿汉式,我们做了2处优化:
一、并不直接实例对象。
二、调用getInstance()方法时会进行一个为空判断,保证不会每次调用getInstance()方法都会new一个对象。
但是懒汉式也有缺点:
它在多线程并发下这样的实现是无法保证实例是唯一的。
什么意思呢?比如有多个线程同时调用了getInstance()方法,它们同时进入判断是否为空,为空创建对象,就有可能同时创建了多个对象。
针对懒汉式的缺点,又出现了第3种写法,懒汉式线程安全:
就是在为空判断时加上synchronize同步锁,此处有两种方式使用synchronize同步锁:
/**
* 懒汉式线程安全
*/
public class LazySafetySingleton {
private static LazySafetySingleton mLazySafetySingleton;
//构造方法私有
private LazySafetySingleton() {
}
//第一种:方法中声明synchronized关键字
public static synchronized LazySafetySingleton getInstance() {
if (mLazySafetySingleton == null) {
mLazySafetySingleton = new LazySafetySingleton();
}
return mLazySafetySingleton;
}
//第二种:同步代码块实现
public static LazySafetySingleton getInstance() {
synchronized (LazySafetySingleton.class) {
if (mLazySafetySingleton == null) {
mLazySafetySingleton = new LazySafetySingleton();
}
}
return mLazySafetySingleton;
}
}
解决了线程安全的缺点,但是又来一个缺点:
如果有多个线程同时调用了getInstance()方法,第一个进去会将对象锁上,后面的就必须等待第一个执行完才能进去第二个,当调用这个方法的线程很多时,就限定了访问速度,这样就会导致性能上的缺陷。
为了解决这个问题,下面介绍单例设计模式的第四种写法,DCL模式( DoubleCheckedLock双检锁模式):
/**
* DCL模式
*/
public class DclSingleton {
//使用volatile关键字
private static volatile DclSingleton mDclSingleton = null;
private DclSingleton(){
}
public static DclSingleton getInstance(){
//避免不必要的同步
if (mDclSingleton == null){
//首次初始化对象的时候同步
synchronized (DclSingleton.class){
//第一次调用时初始化
if (mDclSingleton == null){
//这行代码在不同编译器上的行为是无法预知的
mDclSingleton = new DclSingleton();
}
}
}
//之后的获取不需要同步锁
return mDclSingleton;
}
}
可以看到我们在这里使用了volatile关键字,因为JVM(java虚拟机)的即时编译器中存在指令重排序的优化(这里不做深究,大家只要知道因为多线程可能导致其中几行代码不是顺序执行),所以加上volatile关键字来解决这个问题。
这里我们仅仅是在首次初始化对象的时候进行了同步,从而使代码即正确又保证了执行效率。
接着是第五种,也是最推荐使用的一种,静态内部类模式:
/**
* 静态内部类模式
*/
public class StaticInnerSingleton {
private StaticInnerSingleton(){
}
public static StaticInnerSingleton getInstance(){
return SingletonHolder.mStaticInnerSingleton;
}
//静态内部类
private static class SingletonHolder{
private static final StaticInnerSingleton mStaticInnerSingleton = new StaticInnerSingleton();
}
}
静态内部类中使用了static和final,保证了其唯一性,也就是线程安全,它没有性能缺陷,是最推荐使用的一种单例设计模式。
最后一种模式,单例枚举设计模式(java5之后才能实现):
public enum EnumSingleton{
INSTANCE;
}
因为枚举的三个特性,自由序列化,线程安全,保证单例。简简单单的一点代码就实现了一个线程安全,懒加载的单例。是不是完美的应用了enum的性质?
优势:写法简单,线程安全
劣势:枚举类型的内存消耗要远大于其他类型,在性能上是比较耗内存的。
以上就是此次分享给大家的全部内容,供大家参考,有问题或者更好的建议也欢迎大家提出来。