不使用synchronized和lock，如何实现线程安全的单例

单例，大家肯定都不陌生，这是Java中很重要的一个设计模式。稍微了解一点单例的朋友也都知道实现单例是要考虑并发问题的，一般情况下，我们都会使用synchronized来保证线程安全。

---

那么如果不使用synchronized和lock，如何实现一个线程安全的单例呢？？？

第一种：可以使用饿汉模式实现单例

例如：

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

第二种：可以使用饿汉模式的变种来实现单例

例如：

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

使用static来定义静态成员变量或静态代码，借助class的类加载机制实现线程安全单例。

第三种：可以通过静态内部类实现

例如：

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

这种和前两种相比是对前两种的优化，使用了lazy-loading。singleton类被装载了，但是instance没有立即初始化。因为SingletonHolder类没有被主动使用 ，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

第四种：可以通过枚举的方式

例如：

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

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程的同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒

---

以上四种方式其原理都是借助了类加载的时候初始化单例。即借助了ClassLoader的线程安全机制

所谓的ClassLoader的线程安全机制，就是ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。也正是这样，除非被重写，这个方法默认在整个加载过程中都是同步的，也就保证了线程安全。

所以以上的几种方式，虽然并没有显示使用synchronized，但是还是在其底层实现原理中使用了synchronized

上面的都是隐形使用了synchronized，不使用synchronized，可以使用Lock。如果以上都不使用的话，还有什么方法可以实现呢？？？

---

最后一种：可以使用CAS

CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量的时候，只有一个线程能更新变量的值，而其他的线程都失败，失败的线程并不会挂起，而是被告知这次竞争中失败，并可以再次尝试。实现单例的方法如下

public class Singleton {
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();

    private Singleton() {}

    public static Singleton getInstance() {
        for (;;) {
            Singleton singleton = INSTANCE.get();
            if (null != singleton) {
                return singleton;
            }

            singleton = new Singleton();
            if (INSTANCE.compareAndSet(null, singleton)) {
                return singleton;
            }
        }
    }
}

这种方法实现的单例有什么优缺点呢？？？

优点：
用CAS的好处是不需要使用传统的锁机制来保证线程安全，CAS是一种基于忙等待的算法，依赖底层硬件的实现，相对于锁他没有线程切换和阻塞的额外消耗，可以支持较大的并行度。

缺点：
CAS的一个重要缺点就是如果忙等待一直不成功(一直死循环中)，会对CPU造成较大的执行开销。
另外，如果N个线程同时执行到singleton = new Singleton();的时候，会有大量的对象创建，很可能会导致内存溢出。所以不建议使用这种实现方式。

---

PS：实际工作中不建议使用使用CAS实现单例