单例模式

单例模式相信大家都不陌生，它保证了每个类只有一个实例，最近从内存的角度重新认识了单例模式，感觉对它的理解有多了一些。

说到单例，首先我们就要从经常使用的实例化对象语句开始，比如说Car c = new Car();首先看等式的左边，在内存中的表现就是在栈里面新建了一个Car类型的变量c，等式的右边就相当于在内存里的堆中新建了一个Car的对象，等号就是把在堆中建立的对象的地址值赋给栈中的变量c。当我们使用语句 Car c1 = new Car();Car c2 = new Car();就相当于在堆中创建了两个car对象，变量c1和c2分别指向这两个对象的地址值。

单例模式就是使一个类在内存中只存在一个对象。

为了保证对象唯一，定义类的时候三步走就可以了：

1.将构造函数私有化，这样其他程序就不能建立该类的对象。

2.为了保证其他程序可以访问到该类的对象，在类中创建一个本类对象。

3.为了方便其他程序对自定义对象的访问，提供一些访问方式。

在代码中体现为：

class Car
{
	//1.构造函数私有化
	private Car(){}
	//2.创建了一个本类对象
	private static Car c = new Car();
	//3.提供一个获取对象的方法
	//  因为只能通过类名直接访问方法，所以该方法设置成静态的，对应的创建的Car类对象c也是静态的
	public static Car getInstance()
	{
		return c;
	}
}

class SingleDemo
{
	public static void main(String[] args)
	{
		//4.通过暴露出来的方法访问该类
		Car car = Car.getInstance();
	}
}

这样就创建了最基本的单例模式。

创建单例模式还有另外一种方式，就是在访问该类的方法时再实例对象：

class Car
{
	private Car(){}
	private static Car c = null;
	public static Car getInstance()
	{
		if(c == null)
			c = new Car();
		return c;
	}
}

class SingleDemo
{
	public static void main(String[] args)
	{
		Car car = Car.getInstance();
	}
}

我们可以看出这两种单例模式的区别就在于初始化对象的时间不同，第一段代码中先初始化对象，称为饿汉式，第二段代码对象是在方法被调用的时候才初始化对象，这就是对象的延时加载，也叫懒汉式的单例模式。饿汉式就是类刚加载近内存，就创建了该类的对象。而懒汉式是类加载进内存时，对象还没有存在，只有调用了getInstance方法时，才建立对象。

懒汉式的单例模式会存在线程安全的问题，所以需要加一个锁来解决这个问题：

class Car
{
	private Car(){}
	private static Car c = null;
	//synchronized关键字保证了一个线程在访问这个对象时，其他线程必须等待
	//但是这样每一个线程都需要进行加锁的判断，会非常消耗内存
	public static synchronized Car getInstance()
	{
		if(c == null)
			c = new Car();
		return c;
	}
}

最终优化后的懒汉式单例模式为：

class Car
{
	private Car(){}
	private static Car c = null;
	public static Car getInstance()
	{
		if(c == null)
		{
			synchronized(Single.class)
			{
				if(s==null)
					c = new Car();
			}
		}
		return c;
	}
}