记录：单例模式的几种写法

单例模式概念，摘自百度百科：

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

单例模式的几种写法：
1、饿汉式

public class SingleClass1 {
	
	private static SingleClass1 singleClass1 = new SingleClass1();

	private SingleClass1() {
		
	}
	
	public static SingleClass1 getInstance() {
		return singleClass1;
	}
	
	public static void main(String[] args) {
		SingleClass1 s1 = SingleClass1.getInstance();
		SingleClass1 s2 = SingleClass1.getInstance();
		System.out.println(s1 == s2);
		System.out.println(s1.toString());
		System.out.println(s2.toString());
	}
}

加载类的时候就直接将单例初始化了。
相对应的方式就是懒加载。

2、懒汉式（懒加载）
一般来讲，按照上面饿汉式的写法，懒加载的代码大概是这样的：

public class DoubleNegativeClass1 {

	private static DoubleNegativeClass1 doubleNegativeClass1 = null;

    private DoubleNegativeClass1(){

    }

    public static DoubleNegativeClass1 getInstance(){
        if(doubleNegativeClass1 == null){
            doubleNegativeClass1 = new DoubleNegativeClass1();
        }

        return doubleNegativeClass1;
    }
}

不过这样的写法是不对的，在多线程环境下，如果一个线程执行到了

if(doubleNegativeClass1 == null)

这一步时，把cpu交给了另一个线程，此时实例仍为空，这样另一个线程判断后创建了实例，然后第一个线程会继续刚才的步骤也创建实例，这样就有两个实例了，就不是单例模式了，这样写是线程不安全的。

验证代码：

public static void main(String[] args) {
        for(int i = 0 ; i < 1000 ; i++){
            new Thread(){
                @Override
                public void run() {
                    DoubleNegativeClass1 dn = DoubleNegativeClass1.getInstance();
                    System.out.println(dn.hashCode());
                }
            }.start();
        }
    }

我创建了1000个线程，运行的方法就是获得这个单例的实例对象的hashcode，如果有不止一个的话，就说明创建了不止一个实例，就不是单例模式。
经过几次运行后，出现了这种情况：

第一个实例的hashcode和后面的不一样，说明这样写是线程不安全的。
抢救办法，在getInstance方法上加synchronized关键字：

public class SingletonBySynchronized {

	private static SingletonBySynchronized singletonBySynchronized = null;
	
	private SingletonBySynchronized() {
		
	}
	
	//就这里，加上synchronized关键字
	public synchronized static SingletonBySynchronized getInstance() {
		if(singletonBySynchronized == null) {
			singletonBySynchronized = new SingletonBySynchronized();
		}
		return singletonBySynchronized;
	}
	
	private String sout(){
        return "调用单例模式的方法......";
    }

}

这个写法是线程安全的，但是网上说效率低，因为每次调用获得实例方法的时候都要先获得锁，最后还要释放锁。

3、双重校验
上代码：

public class DoubleNegativeClass2 {

    //一定要加volatile关键字
	private volatile static DoubleNegativeClass2 doubleNegativeClass2 = null;

    private DoubleNegativeClass2(){

    }

    public static DoubleNegativeClass2 getInstance(){
        if(doubleNegativeClass2 == null){
            synchronized (DoubleNegativeClass2.class) {
                if(doubleNegativeClass2 == null) {
                    doubleNegativeClass2 = new DoubleNegativeClass2();
                }
            }
        }

        return doubleNegativeClass2;
    }

    private String sout(){
        return "调用单例模式的方法......";
    }
}

先判断一次当前实例是否为空，如果为空，才获得对象锁，这样就不用每次调用getInstance方法都要获得对象锁了，为了防止像懒汉式里那样线程不安全，在获得对象锁后再进行一次判断是否为空，然后再去创建实例。

这里定义对象实例变量的时候，必须要加volatile关键字。因为doubleNegativeClass2 = new DoubleNegativeClass2();这句代码不是原子操作，具体分为以下几步：
1、给DoubleNegativeClass2实例分配内存
2、调用DoubleNegativeClass2构造器
3、把变量指向对象实例的内存。
在执行这一步代码的时候，由于cpu有指令重排的特性，所以在不影响最终结果的情况下，指令执行顺序可能不会是上面那样，就有可能出现以下情况：

线程1执行1—>3步骤，这时候doubleNegativeClass2变量已经是非空了，但是第2步对象实例的构造器还没有被调用。
然后此时线程2获得cpu，判断doubleNegativeClass2为非空，直接就结束方法返回了，但是此时实例还尚未构造，调用方法的话就有可能会有空指针什么的问题。
所以加入volatile关键字，以保证没有指令重排的发生，就按照1—>2—>3的顺序去执行。

不过我写了个main方法，运行了几十次，也没出现过空指针什么的情况，不知道是我写的有问题还是什么别的。。加上volatile肯定是没错啦。

4、静态内部类
上代码：

public class SingletonByInnerClass {

	private static class Singleton1{
		private static final SingletonByInnerClass singletonByInnerClass = new SingletonByInnerClass();
	}
	
	public static SingletonByInnerClass getInstance() {
		return Singleton1.singletonByInnerClass;
	}
	
	private SingletonByInnerClass() {
		
	}
}

把实例交给静态内部类托管，这样只有在类加载的时候，也就是第一次调用getInstance方法的时候才会创建实例对象。类加载的时候只有一个线程，其他线程进不来。
网上比较推荐这个方式。

5、枚举类
这个我没有尝试，直接贴网上代码：

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

这是个不太常规的实现方式。

以上是近期的一点记录，其实内容和网上的东西大致是差不多的，但是自己写一遍总归有点好处。