单例模式

单例模式，顾名思义就是某个类只有一个实例，你可能要说了，那还不简单，只实例化一次不久行了，确实是这样的。但是如果我们需要在不同的类中，不同的场景下使用这个实例，但是这个实例并不需要每次都实例化一次，例如配置文件的读取，我们只需要在初始化时将其实例化，然后就让它放在内存中，下次要用时调用就行，因为这个实例每次都是一样的。

那么我们需要怎么做呢？单例模式。

要实现单例，我们首先需要阻止其他的类通过构造函数对需要单例的类进行实例化，那么我们就需要将构造函数私有化，这是单例模式首先需要做的；然后需要考虑，怎样让外部的类每次都拿到的都是同一个实例？没错，static这个词马上就会浮现在脑中，静态参数可以面向整个java项目的线程。至于通过什么方式获取，编程习惯决定了两种不同的风格：

首先看懒汉式：

public class singletonLazy {
	//全局单例，通过单例模式永远获取的都将是这一个实例
	private static singletonLazy instance = null;
	
	//私有化构造方法，使获取实例的入口只有一个
	private singletonLazy()
	{
		//
	}
	
	//获取实例的入口
	//这里之所以用synchronized，是因为有可能在两个线程同时访问这个方法时，两个都认为没有实例，都创建了一个实例，使实例有两分，出现线程安全的问题
	public static synchronized singletonLazy getSingletonTestClass()
	{
		if(null == instance)
		{
			instance = new singletonLazy();
		}
		
		return instance;
	}
	
	public void print()
	{
		System.out.println("lazy");
	}
}

public class singletonHungry {
	private static singletonHungry instance = new singletonHungry();
	
	private singletonHungry()
	{
		//
	}
	
	public static singletonHungry getInstance()
	{
		return instance;
	}
	
	public void print()
	{
		System.out.println("hungry");
	}
}

这两个思想都是懒汉式透露出来的，我们可以看到，懒汉式是在调用获取实例的方法时才去判断实例时候已经在内存中存在，如果不存在再实例化一个。延迟加载也是这样的思想，直到用到再去加载想要的内容，缓存则是首先在内存中找想要的东西，如果没有再去硬盘或者数据库中找。懒汉式表现出了这两种思想。缓存思想就是典型的空间换时间的做法。

任何事物都不是完美的，懒汉式也有缺点，也就是在不加同步的情况下是线程不安全的。而饿汉式则是线程安全的，因为jvm在装载类时只会装载一次，而实例化恰好是在这个过程中完成的。

解决方案就是上面我们看到的懒汉式的代码，对实例获取方法进行加锁，加线程同步锁。但是这样会降低整个访问速度，因为如果多个线程竞争这个方法，就会导致等待，降低访问。

我们从代码中可以分析看到，真正会造成线程安全问题的其实是”instance = new singletonLazy();“这么一句话，所以我们仅仅需要对这句话进行同步即可。

public class synchronizedLazy {
	//volatile的作用是每次对变量的改变都会立即被写入内存，而每次读变量都是从内存去取
	//这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
	private static volatile synchronizedLazy instance = null;
	
	private synchronizedLazy()
	{
		//
	}
	
	public static synchronizedLazy getInstance()
	{
		if(null == instance)
		{
			//在未初始化时才进行同步才做，因为同步降低了性能
			synchronized (synchronizedLazy.class) {
				//之所以要重新判断，是因为避免在判断之后和进入同步区域之前有线程进行了创建
				if(null == instance)
				{
					instance = new synchronizedLazy();
				}
			}
		}
		
		return instance;
	}
	
	public void print()
	{
		System.out.println("synchronized");
	}
}

答案是肯定，因为总是有那么一群牛X的Geek研究这些东西，然后造福我们这些码农。

public class LazyInitialHolder {
	//静态内部类，因为是静态的，所以这个类跟寄主类并没有关联关系，也就是这个内部类并不属于寄主类
	//所以在寄主类初始化时并不会初始化一个静态内部类的实例，只要不使用就不会创建实例
	//所以Instance并不会在一开始就被建立
	//但是由于jvm会缺省的对静态初始化器进行同步控制，所以就不会存在同步的问题
	private static class SingletonHolder{
		private static LazyInitialHolder instance = new LazyInitialHolder();
	}
	
	private LazyInitialHolder()
	{
		//
	}
	
	//在这个方法调用时，才会去执行内部类的方法获取实例
	public static LazyInitialHolder getInstance()
	{
		return SingletonHolder.instance;
	}
	
	public void print()
	{
		System.out.println("LazyInitialHolder");
	}
}

内部类一个显著的好处就是可以解决关于类的多继承问题（虽然接口可以实现多继承 ，但是在某些情况下我们需要多继承一些类或者抽象类），但是我们这里并没有用到这个内部类的特性，而是用到了内部类加载时机。

对于内部类来说，尤其是静态内部类，其实他已经不属于宿主类了，而是独立的存在着，但是只能通过宿主类进行访问，而在宿主类被装载，甚至被实例化时，内部类并不会进行初始化对象，也就是不会执行“private static LazyInitialHolder instance = new LazyInitialHolder();”，只有当用到这个内部类中的方法或者变量被用到时，内部类才会被加载，然后初始化对象，用这样的方式就达到了延迟加载的目的。而如何保证线程安全呢？这就用到了JVM的自动操作，JVM会对由静态初始化器初始数据时进行缺省的同步控制，保证线程安全，那么什么是静态初始化器呢？其实就是含有静态字段的类或者方法，变量等，或者static块。

由此，我们就巧妙的解决了延迟加载和线程安全的问题。

ok，我们单例模式就介绍完了，总结一下，我们发现单例模式的核心思想就是控制实例数目，防止重复实例化影响效率。

单例模式组要要考虑的几个问题：1.如何让程序不能被随意实例化；2.如何提供接口让用户得到实例；3.延迟加载；4.线程安全。