本文共 6610 字，大约阅读时间需要 22 分钟。

一. Spring单例和多例创建

在Spring中，bean可以被定义为两种模式：prototype（多例）和singleton（单例）

singleton（单例）：只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一的实例。prototype（多例）：对这个bean的每次请求都会创建一个新的bean实例，类似于new。

Spring bean 默认是单例模式。

实战演示:

1,在配置文件中：

2,在测试类中代码：

ApplicationContext context =new ApplicationContext("applicationContext.xml"); Hi hi1 = (Hi) context.getBean("hi"); Hi hi2 = (Hi) context.getBean("hi") System.out.println(hi1); System.out.println(hi2);

结论：二个变量指向一个对象。

3.将配置文件改为：

其他的不变，运行测试类，

结果为：每次访问bean，均创建一个新实例。

二，实现原理分析

Spring所谓单例，顾名思义，所指的就是单个实例，也就是说要保证一个类仅有一个实例。单例模式有以下的特点：

①单例类只能有一个实例 ②单例类必须自己创建自己的唯一实例 ③单例类必须给所有其他对象提供这一实例.

1.饿汉式单例：

Public class Singleton1{
      Private static final Singleton1 instance=new Singleton1();         //私有的默认构造函数        Private Singleton1(){
   }         //静态工厂方法        Public static Singleton1 getInstance()   {
                 return instance;        }     }

2.懒汉式单例：

Public class Singleton2{
                Private static final Singleton2 instance=null;                                      Private Singleton2(){
   }             //静态工厂方法            Public synchronized static Singleton2 getInstance()     {
             if(instance==null)          {
                           instance=new Singleton2();                  }                  return instance;             }    }  //线程安全的单例创建,"双重检查锁"public class Singleton {
       private static volatile Singleton singleton = null;    private Singleton(){
   }    public static Singleton getSingleton(){
           if(singleton == null){
               synchronized (Singleton.class){
                   if(singleton == null){
                       singleton = new Singleton();                }            }        }        return singleton;    }    }

3.恶汉式单例和懒汉式单例的比较

饿汉式单例在自己被加载时就将自己实例化，如果从资源利用效率角度来讲，比懒汉式单例类稍差些。但是从速度和反应时间角度来讲，则比懒汉式要稍好些。但是遗憾的是：懒汉式单例类也不能被继承。

4.重点介绍：单例注册表

单例模式有饿汉模式、懒汉模式、静态内部类、枚举等方式实现，但由于以上模式的构造方法是私有的，不可继承，Spring为实现单例类可继承，使用的是单例注册表的方式（登记式单例）。 单例注册表单例实际上维护的是一组单例类的实例，将这些实例存储到一个Map(登记簿)中，对于已经登记过的单例，则从工厂直接返回，对于没有登记的，则先登记，而后返回 1. 使用map实现注册表； 2. 使用protect修饰构造方法； 有的时候，我们不希望在一开始的时候就把一个类写成单例模式，但是在运用的时候，我们却可以像单例一样使用他 最典型的例子就是spring，他的默认类型就是单例，spring是如何做到把不是单例的类变成单例呢？ 这就用到了登记式单例 其实登记式单例并没有去改变类，他所做的就是起到一个登记的作用，如果没有登记，他就给你登记，并把生成的实例保存起来，下次你要用的时候直接给你。 IOC容器就是做的这个事，你需要就找他去拿，他就可以很方便的实现Bean的管理。

Import java.util.HashMap;    Public class RegSingleton{
       //使用一个map来当注册表   Static private HashMap registry=new HashMap();       //静态块，在类被加载时自动执行   Static   {
            RegSingleton rs=new RegSingleton();         registry.put(rs.getClass().getName(),rs);       }       //受保护的默认构造函数，如果为继承关系，则可以调用，克服了单 例类不能为继承的缺点       Protected RegSingleton(){
   }       //静态工厂方法，返回此类的唯一实例      public static RegSingleton getInstance(String name)  {
           if(name==null){
             name=”RegSingleton”;        }    if(registry.get(name)==null){
             try      {
                 registry.put(name,Class.forName(name).newInstance());           }Catch(Exception ex)       {
              ex.printStackTrace();       }        }        Return (RegSingleton)registry.get(name);       }    }

5.看下spring的源码：

public abstract class AbstractBeanFactory implements ConfigurableBeanFactory{
          /**      * 充当了Bean实例的缓存，实现方式和单例注册表相同      */       private final Map singletonCache=new HashMap();       public Object getBean(String name)throws BeansException{
              return getBean(name,null,null);       }        ...       public Object getBean(String name,Class requiredType,Object[] args)throws BeansException   {
             //对传入的Bean name稍做处理，防止传入的Bean name名有非法字符(或则做转码)          String beanName=transformedBeanName(name);          Object bean=null;          //手工检测单例注册表          Object sharedInstance=null;          //使用了代码锁定同步块，原理和同步方法相似，但是这种写法效率更高          synchronized(this.singletonCache){
                sharedInstance=this.singletonCache.get(beanName);           }          if(sharedInstance!=null){
                ...             //返回合适的缓存Bean实例             bean=getObjectForSharedInstance(name,sharedInstance);          }else{
               ...            //取得Bean的定义            RootBeanDefinition mergedBeanDefinition=getMergedBeanDefinition(beanName,false);             ...            //根据Bean定义判断，此判断依据通常来自于组件配置文件的单例属性开关            //
               //如果是单例，做如下处理            if(mergedBeanDefinition.isSingleton()){
                  synchronized(this.singletonCache){
                   //再次检测单例注册表                 sharedInstance=this.singletonCache.get(beanName);                 if(sharedInstance==null){
                       ...                   try {
                         //真正创建Bean实例                      sharedInstance=createBean(beanName,mergedBeanDefinition,args);                      //向单例注册表注册Bean实例                       addSingleton(beanName,sharedInstance);                   }catch (Exception ex) {
                         ...                   }finally{
                         ...                  }                 }               }              bean=getObjectForSharedInstance(name,sharedInstance);            }           //如果是非单例，即prototpye，每次都要新创建一个Bean实例           //
              else{
                 bean=createBean(beanName,mergedBeanDefinition,args);           }    }    ...       return bean;    }    }

==================================================================

下面补充下其他的创建线程安全的单例方式：

1.通过静态内部类来实现：public class Singleton {
       private static class SingletonHolder {
           private static final Singleton INSTANCE = new Singleton();    }    private Singleton (){
   }    public static final Singleton getInstance() {
           return SingletonHolder.INSTANCE;    }}这种方式相比前面两种有所优化，就是使用了lazy-loading。Singleton类被装载了，但是instance并没有立即初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance2.使用CAS。CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。public class Singleton {
       private static final AtomicReference
   
     INSTANCE = new AtomicReference
    
     ();    private Singleton() {
   }    public static Singleton getInstance()     {
           for (;;)         {
               Singleton singleton = INSTANCE.get();            if (null != singleton)             {
                   return singleton;            }            singleton = new Singleton();            if (INSTANCE.compareAndSet(null, singleton))             {
                   return singleton;            }        }    }}用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。另外，如果N个线程同时执行到singleton = new Singleton();的时候，会有大量对象创建，很可能导致内存溢出。
    
   

转载地址：http://doxai.baihongyu.com/