如何实现Singleton（单例）模式

单例模式，也就是针对每个类只能生成该类的一个实例，接下来就介绍一下几种实现的方法。本篇内容借鉴了《剑指Offer》和《effective java》两本书。

既然是单例模式，那么首先要确定的就是该类的构造函数一定是私有的，即不能让其他类去调用这个类的构造函数。

1. 只适用于单线程环境（初级写法）

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

这个类使用一个静态属性Instance，当此属性为null时，才调用构造函数创建新的实例并返回，否则直接返回此属性。当然在多线程的情况下，它会有一定的问题。如果两个线程同时判断instance为null，则会同时创建一个实例，此时类型Singleton1就不再满足单例模式的要求了。

2. 多线程中可以工作，但效率不高（懒汉式）

由1可以得知，我们必须保证判断的时候只能有一个线程来判断instance是否为null，所以可以在判断的地方加上一个锁。如下：

public final class Singleton2 {
	private Singleton2() {}
	public static volatile Singleton2 instance = null;
	//给整个方法加同步，保证只有一个
	public synchronized static Singleton2 getInstance() {			
		if (instance == null)
			instance = new Singleton2();
		return instance;
	}
}

这样就能保证只有一个线程去判断instance是否为null，从而决定是新建实例还是直接返回。当然这也有一个缺点，那就是每次调用方法getInstance去获得实例时，总会试图去加锁，这样会浪费一定的时间。

3. 加同步锁前后两次判断实例是否已存在（双锁检验）

其实刚才我们是在判断前就加锁，从而加锁后再进行判断。但是我们可以先判断instance是否为null，如果不为null不管是哪个线程就都可以直接返回instance；如果为null，那么就要进行加锁，保证创建实例的时候只能有一个线程。判断为null后加锁，进去后还是要判断一次的，因为可能在加锁的过程中，别的线程就提前完成了加锁->创建实例的过程，所以进去后判断若还是为null，则创建实例，否则返回instance。如下：

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

4、公有静态成员是个final域（饿汉式）

当然《剑指Offer》里面用的C#举例子，其实Java也是类似的，只需要将要返回的那个成员设置为公有静态final的，然后直接将其初始化或者在静态语句中初始化，这样在加载这个类的时候也就进行了初始化，保证这个成员就是全局唯一的。如下：

public final class Singleton4 {
	private Singleton4() {}
	public static Singleton4 instance = new Singleton4();
	public static Singleton4 geteInstance(){
        return instance ;
    }
} 

或者

public final class Singleton4 {
	private Singleton4() {}
	public static Singleton4 instance = null;
	static {
		instance = new Singleton4 ();
	}
	public static Singleton4 geteInstance(){
        return instance ;
    }
} 

但是这种方法使得每次加载类都会加载，并不是按需创建。

5、按需创建实例（内部类）

在内部定义一个内部类SingletonHolder，只有当调用getInstance()方法获取那个INSTANCE时，才会加载里面的内部类SingletonHolder，进而执行初始化语句获得实例。其实能够看出来，和前面一种是类似的，只是这次将初始化语句放到了一个内部类中，因为在加载这个类的时候，如果没有使用的话是不加载内部类的，所以只有使用时才会加载内部类，进而执行初始化语句获得实例。

public class Singleton5 {

    private static class SingletonHolder{
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    private Singleton5() {}
 
    public static Singleton5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

6、枚举类型

这个是《effective java》里面的，它生命了一个包含单个元素的枚举类型如下：

public enum Singleton{
    INSTANCE;
    public void whateverMethod() {
        
    }
}

这种方式是线程安全的，而且无偿的提供了序列化机制，绝对防止多次实例化。