单例的三种实现方式

实现1:

 

public class Singleton {

     

     private static Singleton instance;

      private Singleton (){ //首先有一个私有的构造器

       }

 

     public static Singleton getInstance() {
     if(instance==null){
         instance=new Singleton ();
      }
      return instance;
     }

}

 

这种方式是线程不安全的,如果多个线程同时访问的话就可能有多个对象产生,如果在get方法中加同步块的话会影响性能。

 

实现2:

 

public class Singleton {
 
 private Singleton(){
 
 }
 private static Singleton instance =new Singleton();
 
 public static Singleton getInstance(){
  return instance;
 }

}

 

 

这种方式虽然不存在安全性问题,但是在程序启动的时候就会初始化。

 

实现3:

public class Singleton {

 private static class SingletonHolder {
  static Singleton instance = new Singleton();
 }

 public static Singleton getInstance() {
  return SingletonHolder.instance;
 }

}

 

3种方式中这是最好的解决方案,既解决了线程同步的问题,有在调用的时候才初始化。

Java语言中实现的关键是静态实例变量和私有构造方法

 

---第3种方式的说明

2012-02-13 21:51

Java中一种更好的单例实现方式

5.3.8  在Java中一种更好的单例实现方式

根据上面的分析,常见的两种单例实现方式都存在小小的缺陷,那么有没有一种方案,既能够实现延迟加载,又能够实现线程安全呢?

还真有高人想到这样的解决方案了,这个解决方案被称为Lazy initialization holder class模式,这个模式综合使用了Java的类级内部类和多线程缺省同步锁的知识,很巧妙地同时实现了延迟加载和线程安全。

1、相应的基础知识

先简单地看看类级内部类相关的知识。

什么是类级内部类?

简单点说,类级内部类指的是,有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。

类级内部类相当于其外部类的static成分,它的对象与外部类对象间不存在依赖关系,因此可直接创建。而对象级内部类的实例,是绑定在外部对象实例中的。

类级内部类中,可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。

类级内部类相当于其外部类的成员,只有在第一次被使用的时候才会被装载。

再来看看多线程缺省同步锁的知识。

大家都知道,在多线程开发中,为了解决并发问题,主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中,JVM已经隐含地为您执行了同步,这些情况下就不用自己再来进行同步控制了。这些情况包括:

由静态初始化器(在静态字段上或 static{} 块中的初始化器)初始化数据时

访问 final 字段时

在创建线程之前创建对象时

线程可以看见它将要处理的对象时

2、解决方案的思路

要想很简单地实现线程安全,可以采用静态初始化器的方式,它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来,不是会浪费一定的空间吗?因为这种实现方式,会在类装载的时候就初始化对象,不管你需不需要。

如果现在有一种方法能够让类装载的时候不去初始化对象,那不就解决问题了?一种可行的方式就是采用类级内部类,在这个类级内部类里面去创建对象实例。这样一来,只要不使用到这个类级内部类,那就不会创建对象实例,从而同时实现延迟加载和线程安全。

看看代码示例可能会更清晰一些,示例代码如下:

  1. public class Singleton {  
  2.     /**  
  3.      * 类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例  
  4.      * 没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载  
  5.      */  
  6.     private static class SingletonHolder{  
  7.         /**  
  8.          * 静态初始化器,由JVM来保证线程安全  
  9.          */  
  10.         private static Singleton instance = new Singleton();  
  11.     }  
  12.     /**  
  13.      * 私有化构造方法  
  14.      */  
  15.     private Singleton(){  
  16.     }  
  17.     public static  Singleton getInstance(){  
  18.         return SingletonHolder.instance;  
  19.     }  

仔细想想,是不是很巧妙呢!

当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance,导致SingletonHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建Singleton的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。

这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。

 来自:http://hi.baidu.com/mingrensun/item/7cd9e7c185f5df69f7c95d3f

 

你可能感兴趣的:(单例的三种实现方式)