关闭

Java单例的几种写法和优缺点

82人阅读 评论(0) 收藏 举报
分类:

一 单例模式介绍及它的使用场景

单例模式是应用最广的模式,也是我最先知道的一种设计模式,在深入了解单例模式之前,每当遇到如:getInstance()这样的创建实例的代码时,我都会把它当做一种单例模式的实现。其实经常使用的图片加载框架ImageLoader的实例创建就是使用了单例模式,因为这个ImageLoader中含有线程池、缓存系统、网络请求,很消耗资源,不应该创建多个对象,这时候就需要用到单例模式。

ImageLoader的创建代码如下:

ImageLoader.getInstance();// 在自己的Application中创建全局实例
.....
//getInstance()执行的源码
 public static ImageLoader getInstance() {
        if(instance == null) {//双重校验DCL单例模式
            Class var0 = ImageLoader.class;
            synchronized(ImageLoader.class) {//同步代码块
                if(instance == null) {
                    instance = new ImageLoader();//创建一个新的实例
                }
            }
        }
        return instance;//返回一个实例
    }

因此,在我们创建一个对象需要消耗过多的资源时,便可以考虑使用单例模式。

二 单例模式的结构图以及创建的关键点?

单例模式的定义是它应该保证一个类仅有一个实例,同时这个类还必须提供一个访问该类的全局访问点。如下图是单例模式的结构图:

这里写图片描述

实现单例模式有以下几个关键点:
(1)其构造函数不对外开放,一般为private;
(2)通过一个静态方法或者枚举返回单例类对象;
(3)确保单例类的对象有且只有一个,尤其要注意多线程的场景;
(4)确保单例类对象在反序列化时不会重新创建对象;<喎�"/kf/ware/vc/" target="_blank" class="keylink">vcD4NCjxwPs2ouf29q7WlwP3A4LXEubnU7Lqvyv3LvdPQu6+jrMq5tcO/zbuntsuyu8Tczai5/W5ld7XE0M7KvcrWtq+5udTstaXA/cDgtcS21M/zoaO1pcD9wOC74db3tq+xqcK20ru49rmr09C1xL6yzKy3vbeoo6y/zbuntsu199PD1eK49r6yzKy1xLe9t6i78cihtb21pcD9wOC1xM6o0rvKtcD9oaPU2rvxyKHV4rj2taXA/cDgtcTKsbry0OjSqsi3saPV4rj2uf2zzMrHz9+zzLCyyKu1xKGjPC9wPg0KPGgyIGlkPQ=="三-单例模式的七种实现方式">三 单例模式的七种实现方式

(1)懒汉式(线程不安全)

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {  
    //私有的构造函数
    private Singleton() {} 
    //私有的静态变量 
    private static Singleton single=null;  
    //暴露的公有静态方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}

懒汉式(线程不安全)的单例模式分为三个部分:私有的构造方法,私有的全局静态变量,公有的静态方法。

其中起到重要作用的是静态修饰符static关键字,我们知道在程序中,任何变量或者代码都是在编译时由系统自动分配内存来存储的,而所谓静态就是指在编译后所分配的内存会一直存在,直到程序退出内存才会释放这个空间,因此也就保证了单例类的实例一旦创建,便不会被系统回收,除非手动设置为null。

这种方式创建的缺点是存在线程不安全的问题,解决的办法就是使用synchronized 关键字,便是单例模式的第二种写法了。

(2)懒汉式(线程安全)

public class Singleton {  
    //私有的静态变量
    private static Singleton instance;  
    //私有的构造方法
    private Singleton (){};
    //公有的同步静态方法
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}  

这种单例实现方式的getInstance()方法中添加了synchronized 关键字,也就是告诉Java(JVM)getInstance是一个同步方法。

同步的意思是当两个并发线程访问同一个类中的这个synchronized同步方法时, 一个时间内只能有一个线程得到执行,另一个线程必须等待当前线程执行完才能执行,因此同步方法使得线程安全,保证了单例只有唯一个实例。

但是它的缺点在于每次调用getInstance()都进行同步,造成了不必要的同步开销。这种模式一般不建议使用。

(3)饿汉模式(线程安全)
代码实现如下:

//饿汉式单例类.在类初始化时,已经自行实例化   
public class Singleton {  
    //static修饰的静态变量在内存中一旦创建,便永久存在
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
} 

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。其中instance=new Singleton()可以写成:

 static {  
    instance = new Singleton();  
    }  

属于变种的饿汉单例模式,也是基于classloder机制避免了多线程的同步问题,instance在类装载时就实例化了。

(4)DCL双重校验模式

public class Singleton {  
    private static Singleton singleton;  //静态变量
    private Singleton (){}  //私有构造函数
    public static Singleton getInstance() {  
      if (singleton == null) {  //第一层校验
          synchronized (Singleton.class) {  
          if (singleton == null) {  //第二层校验
              singleton = new Singleton();  
          }  
        }  
      }  
    return singleton;  
    }  
}  

这种模式的亮点在于getInstance()方法上,其中对singleton 进行了两次判断是否空,第一层判断是为了避免不必要的同步,第二层的判断是为了在null的情况下才创建实例。具体我们来分析一下:

假设线程A执行到了singleton = new Singleton(); 语句,这里看起来是一句代码,但是它并不是一个原子操作,这句代码最终会被编译成多条汇编指令,它大致会做三件事情:
(a)给Singleton的实例分配内存
(b)调用Singleton()的构造函数,初始化成员字段;
(c)将singleton对象指向分配的内存空间(即singleton不为空了);

但是由于Java编译器允许处理器乱序执行,以及在jdk1.5之前,JMM(Java Memory Model:java内存模型)中Cache、寄存器、到主内存的回写顺序规定,上面的步骤b 步骤c的执行顺序是不保证了。也就是说执行顺序可能是a-b-c,也可能是a-c-b,如果是后者的指向顺序,并且恰恰在c执行完毕,b尚未执行时,被切换到线程B中,这时候因为singleton在线程A中执行了步骤c了,已经非空了,所以,线程B直接就取走了singleton,再使用时就会出错。这就是DCL失效问题。
但是在JDK1.5之后,官方给出了volatile关键字,将singleton定义的代码改成:

private volatile static Singleton singleton;  //使用volatile 关键字

这样就解决了DCL失效的问题。

(5)静态内部类单例模式

public class Singleton {  
    private Singleton (){} ;//私有的构造函数
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
    //定义的静态内部类
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  //创建实例的地方
    }  
}  

当第一次加载Singleton 类的时候并不会初始化INSTANCE ,只有第一次调用Singleton 的getInstance()方法时才会导致INSTANCE 被初始化。因此,第一次调用getInstance()方法会导致虚拟机加载SingletonHolder 类,这种方式不仅能够确保单例对象的唯一性,同时也延迟了单例的实例化。

(6)枚举单例

前面的几种单例模式实现方式,一般都会稍显麻烦,或是在某些特定的情况下出现一些状况。下面介绍枚举单例模式的实现:

public enum Singleton {  //enum枚举类
    INSTANCE;  
    public void whateverMethod() {  

    }  
}

枚举单例模式最大的优点就是写法简单,枚举在java中与普通的类是一样的,不仅能够有字段,还能够有自己的方法,最重要的是默认枚举实例是线程安全的,并且在任何情况下,它都是一个单例。即使是在反序列化的过程,枚举单例也不会重新生成新的实例。而其他几种方式,必须加入如下方法:

private Object readResolve()  throws ObjectStreamException{
    return INSTANCE;
}

才能保证反序列化时不会生成新的对象。

(7)使用容器实现单例模式
除了上述几种常见的实现单例的方式,还有另一类的实现,代码如下:

public class SingletonManager { 
  private static Map objMap = new HashMap();//使用HashMap作为缓存容器
  private Singleton() { 
  }
  public static void registerService(String key, Objectinstance) {
    if (!objMap.containsKey(key) ) {
      objMap.put(key, instance) ;//第一次是存入Map
    }
  }
  public static ObjectgetService(String key) {
    return objMap.get(key) ;//返回与key相对应的对象
  }
}

在程序的初始,将多种单例模式注入到一个统一的管理类中,在使用时根据key获取对应类型的对象。

Android源码中,APP启动的时候,虚拟机第一次加载该类时会注册各种ServiceFetcher,比如LayoutInflater Service。将这些服务以键值对的形式存储在一个HashMap中,用户使用时只需要根据key来获取到对应的ServiceFetcher,然后通过ServiceFetcher对象的getService函数获取具体的服务对象。当第一次获取时,会调用ServiceFetcher的creatService函数创建服务对象,然后将该对象缓存到一个列表中,下次再取时直接从缓存中获取,避免重复创建对象,从而达到单例的效果。Android中的系统核心服务以单例形式存在,减少了资源消耗。

总结:不管以哪种形式实现单例模式,它们的核心原理是将构造函数私有化,并且通过静态公有方法获取一个唯一的实例,在这个获取的过程中必须保证线程的安全,同时也要防止反序列化导致重新生成实例对象。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:93662次
    • 积分:3109
    • 等级:
    • 排名:第11584名
    • 原创:226篇
    • 转载:1篇
    • 译文:0篇
    • 评论:41条
    最新评论