spring中的设计模式（四）

5.单例模式

首先单例模式中的懒汉和饿汉模式，

懒汉模式：

//懒汉式单例类.在第一次调用的时候实例化自己

public class Singleton {

   private Singleton() {}

   private static Singleton single=null;

   //静态工厂方法

   public static Singleton getInstance() {

        if (single == null) { 

            single = new Singleton();

        } 

       return single;

    }

}

但是这个懒汉模式并没有考虑到线程安全，所以可以有三种方法对这个懒汉模式进行线程安全化

1.给getInstance方法加synchronized 关键字

2.双重检查锁定

public static Singleton getInstance() {

       if (singleton == null) { 

           synchronized (Singleton.class) { 

               if (singleton == null) { 

                  singleton = new Singleton();

               } 

           } 

       } 

       return singleton;

    }

3.静态内部类的方式

public class Singleton { 

   private static class LazyHolder { 

      private static final Singleton INSTANCE = new Singleton(); 

   } 

   private Singleton (){} 

   public static final Singleton getInstance() { 

      return LazyHolder.INSTANCE; 

   } 

} 

饿汉模式：

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton1 {

   private Singleton1() {}

   private static final Singleton1 single = new Singleton1();

   //静态工厂方法

   public static Singleton1 getInstance() {

       return single;

    }

}

 

区别：

饿汉模式天生就是线程安全的，而懒汉模式则需要自行实现线程安全

饿汉式模式在类创建的时候就会实例化一个静态的对象出来，会占用一定内存，但是相应的第一次调用会快一点

懒汉模式的延迟加载，需要调用的时候才会实例化对象

第一种方法实现同步的话，每次调用都会同步，非常耗性能，因为大部分情况是不需要同步的

第二种方法双重判断则避免了每次都需要同步的情况

第三种方法，利用了ClassLoader的机制确保初始化Intance的时候都只有一个线程

 

spring中的单例模式：

spring中的依赖注入都发生在AbstractBeanFactory的getBean方法里面，而getBean方法里面doGetBean方法中的getSingleton方法

 

protected Object getSingleton(String beanName, boolean allowEarlyReference)

    {

        Object singletonObject = singletonObjects.get(beanName);

        if(singletonObject == null &&isSingletonCurrentlyInCreation(beanName))

            synchronized(singletonObjects)

            {

                singletonObject = earlySingletonObjects.get(beanName);

                if(singletonObject == null && allowEarlyReference)

                {

                    ObjectFactory singletonFactory =(ObjectFactory)singletonFactories.get(beanName);

                    if(singletonFactory != null)

                    {

                        singletonObject = singletonFactory.getObject();

                        earlySingletonObjects.put(beanName, singletonObject);

                        singletonFactories.remove(beanName);

                    }

                }

            }

        return singletonObject == NULL_OBJECT ? null : singletonObject;

   }

 

可以看到spring中用的是懒汉模式的双重判断来实现线程安全的，避免在加锁的瞬间有其他注入的时候创建实例