设计模式——单例模式（懒汉、饿汉）

单例模式在我们的代码中应用的太多了，比如我们常把XXXUtils写成单例，Sring管理的类默认也是单例。所以，总结以下吧。

单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

我们先看看jdk源码中的应用：

Runtime：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
	  public static Runtime getRuntime() {
        return currentRuntime;
    }
private Runtime() {}
}

我们也应该都可以理解，单例模式必须做到以下几点：

1.构造方法私有化（保证只从方法中获取，但是必须保证能实例化一个当前对象）。

2.有一个可以获取实例的方法。

在我们常见的单例模式写法中，主要有饿汉和懒汉两种：

饿汉：

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}  

饿汉的主要缺点我们也可以很清楚的发现。无论这个对象在运行时有没有被调用，都会通过静态定义的类 是实例化，当我们不会使用这个类的时候，就浪费了内存。

所以，来看看懒汉写法：

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}  

在懒汉写法中，只有当我们第一次使用的时候才会去实例化。但是，此种写法是线程不安全的，下面举个例子。

if (instance == null) {  

//当有多个线程都执行在此处时，就会执行多次
        instance = new Singleton();  
    }  

所以，又出现了线程安全的懒汉写法：

package yyf.designpatterns.singleton;
/**
 * 
 * @author yuyufeng
 *
 */
public class SingletonClass {
	private static SingletonClass instance = null;

	public static SingletonClass getInstance() {
		if (instance == null) {
			synchronized (SingletonClass.class) {
				if (instance == null) {
					instance = new SingletonClass();
				}
			}
		}
		return instance;
	}

	private SingletonClass() {
	}
}

在此过程中，有双从保险，保证只实例化一次。而且可以看到，因为synchronized锁在方法执行前，不是加在方法上。这样就不用每次执行获取实例方法的时候都锁住此方法，而且在之后的获取过程中都不用执行锁这块代码，提高了获取效率。