单例，是Java中很重要的一个设计模式。

实现单例是要考虑并发(线程安全)问题的。

如何实现一个线程安全的单例？你该如何回答？

饿汉式1

public class Singleton { 

    private static Singleton instance = new Singleton();
    private Singleton (){}

    public static Singleton getInstance() {
      return instance;
    }
}

饿汉式2

public class Singleton {
    private Singleton instance = null;

    static {
        instance = new Singleton();
    }

    private Singleton (){}

    public static Singleton getInstance() {
        return this.instance;
    }
}

这种方式比较常用，但容易产生垃圾对象。使用static来定义静态成员变量或静态代码，借助Class的类加载机制实现线程安全单例。

饿汉式3

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 class Singleton {
    private static Singleton INSTANCE;
 
    /**
     * 懒汉式写法，synchronized修饰保证线程同步
     */
    public static synchronized Singleton GetInstance() {
            if (INSTANCE == null) {
                    INSTANCE = new Singleton();
            }   
            return util;
  }
}

这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

枚举的方式

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

使用示例

    Singleton.instance.doSomeThing();

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

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

使用CAS

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

实现单例的方式如下：

public class Singleton {
    private static final AtomicReference INSTANCE = new AtomicReference();
    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是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。

缺点：1、如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。

​ 2、如果N个线程同时执行到singleton = new Singleton();的时候，会有大量对象创建，很可能导致内存溢出。

其它
https://www.cnblogs.com/dudu19939/p/9668778.html