• 懒汉式

懒汉式是在调用时创建实例，用时间来换空间。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class LazySingleTon {
    private static volatile LazySingleTon instance;

    public static LazySingleTon getInstance(){
        if (instance==null){
            synchronized(LazySingleTon.class){
                if (instance == null) {
                    instance = new LazySingleTon();
                }
                
            }
        }

        return instance;
    }
    
}

双重判断保证了原子性和可见性（synchronized），同时利用volatile来保证有序性，避免指令的重排。

  • 饿汉式

饿汉式在类加载的时候就已经创建好对象，在使用时直接就可以拿到实例，标准的空间换时间。 

1
2
3
4
5
6
7
8
class HungrySingleTon {
    private static HungrySingleTon instance = new HungrySingleTon();

    public static HungrySingleTon getInstance(){
        return instance;
    }

}
  • 静态内部类实现

当外部类加载时不会导致内部类的立即加载，只有当getInstance方法被调用时才会去加载内部类，实现了加载。因为类的加载只会加载一次，所以它时线程安全的。 

1
2
3
4
5
6
7
8
9
10
11
12
13
class StaticInnerSingleTon {

    public StaticInnerSingleTon() {
    }

    private static class SingleTonHolde {
        private static StaticInnerSingleTon instance = new StaticInnerSingleTon();
    }

    public static StaticInnerSingleTon getInstance() {
        return SingleTonHolde.instance;
    }
}
  • 枚举实现 
1
2
3
4
5
6
7
enum ESingleTon {
     single;

   public void singletonOperate(){
       System.out.println("singletonOperate");
   }
}