单例模式的Java实现模式

单例模式的实现

1.懒汉模式（线程不安全）

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

如上，通过提供一个静态的对象instance，利用private权限的构造方法和getInstance()方法来给予访问者一个单例。

缺点是，没有考虑到线程安全，可能存在多个访问者同时访问，并同时构造了多个对象的问题。之所以叫做懒汉模式，主要是因为此种方法可以非常明显的lazy loading。

针对懒汉模式线程不安全的问题，我们自然想到了，在getInstance()方法前加锁，于是就有了第二种实现

2.线程安全的懒汉模式

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

然而并发其实是一种特殊情况，大多时候这个锁占用的额外资源都浪费了，这种打补丁方式写出来的结构效率很低。

3.饿汉模式

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

}

直接在运行这个类的时候进行一次loading，之后直接访问。显然，这种方法没有起到lazy loading的效果，考虑到前面提到的和静态类的对比，这种方法只比静态类多了一个内存常驻而已。

4.静态类内部加载

public class Singleton{
	private static class  SingletonHolder{
		private static Singleton instance = new Singleton();
	}
	private Singleton(){
		System.out.println("Singleton has loaded ")
	}
	public static Singleton getInstance(){
		return SingletonHolder.instance;
	}
}

使用内部类的好处是，静态内部类不会在单例加载时就加载，而是在调用getInstance()方法时才进行加载，达到了类似懒汉模式的效果，而这种方法又是线程安全的。

5.枚举方法

enum SingletonDemo{
	INSTANCE;
	public void testMethods(){
		System.out.println("test")
	}
}

# 调用
public class Hello(){
	public void static main (String [] args){
		SingletonDemo.INSTANCE.test();
	}
}

Effective Java作者Josh Bloch 提倡的方式，在我看来简直是来自神的写法。解决了以下三个问题：
(1)自由串行化。
(2)保证只有一个实例。
(3)线程安全

6.双重校验锁法

public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

接下来我解释一下在并发时，双重校验锁法会有怎样的情景：

STEP 1. 线程A访问getInstance()方法，因为单例还没有实例化，所以进入了锁定块。

STEP 2. 线程B访问getInstance()方法，因为单例还没有实例化，得以访问接下来代码块，而接下来代码块已经被线程1锁定。

STEP 3. 线程A进入下一判断，因为单例还没有实例化，所以进行单例实例化，成功实例化后退出代码块，解除锁定。

STEP 4. 线程B进入接下来代码块，锁定线程，进入下一判断，因为已经实例化，退出代码块，解除锁定。

STEP 5. 线程A获取到了单例实例并返回，线程B没有获取到单例并返回Null。

理论上双重校验锁法是线程安全的，并且，这种方法实现了lazyloading

7. volatile版本Double-Check

对于6中Double-Check这种可能出现的问题（当然这种概率已经非常小了，但毕竟还是有的嘛~），解决方案是：只需要给instance的声明加上volatile关键字即可，volatile版本如下：

public class Singleton{
    private volatile static Singleton singleton = null;
    private Singleton()  {    }
    public static Singleton getInstance()   {
        if (singleton== null)  {
            synchronized (Singleton.class) {
                if (singleton== null)  {
                    singleton= new Singleton();
                }
            }
        }
        return singleton;
    }
}

volatile关键字的一个作用是禁止指令重排，把instance声明为volatile之后，对它的写操作就会有一个内存屏障（什么是内存屏障？），这样，在它的赋值完成之前，就不用会调用读操作。

注意：volatile阻止的不singleton = newSingleton()这句话内部[1-2-3]的指令重排，而是保证了在一个写操作（[1-2-3]）完成之前，不会调用读操作（if (instance == null)）。

也就彻底防止了6中的问题发生。

8.ThreadLocal实现单例模式

public class Singleton{
	private static final ThreadLocal<Singleton> tlSingleton = new ThreadLocal<Singleton>(){
		@Override
		protected Singleton initialValue(){
			return new Singleton();
		}
	};
 /**
     * Get the focus finder for this thread.
     */
    public static Singleton getInstance() {
        return tlSingleton.get();
    }
    // enforce thread local access
    private Singleton() {}

}

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响

9.使用CAS锁实现

package com.example.demo;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 更加优美的Singleton，线程安全的
 */
public class Singleton {

    /**
     * 利用AtomicReference
     */
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();

    private Singleton(){};

    /**
     * 使用CAS确保线程安全
     */
    public static final Singleton getInstance(){
        for (;;){
            Singleton current = INSTANCE.get();
            if (current!=null){
                return current;
            }
            current=new Singleton();
            if (INSTANCE.compareAndSet(null,current)){
                return current;
            }
        }
    }
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
    }
}