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中用的是懒汉模式的双重判断来实现线程安全的，避免在加锁的瞬间有其他注入的时候创建实例
