三种单例模式

三种单例

public class Singleton {
//  三种单例模式
  /* 饿汉式  线程安全
  private static Singleton instance = new Singleton();
  private Singleton(){}
  public static Singleton getInstance(){
    return instance;
  }
   */

  //懒汉式  线程不安全
//  private static Singleton instance;
//  private Singleton(){}
//  public static Singleton getInstance() {
//    if(instance == null){
//      instance = new Singleton();
//    }
//    return instance;
//  }

//  双检锁
private static volatile Singleton instance;
private Singleton(){}
//public static synchronized Singleton getInstance(){
//  if(instance == null){
//    instance = new Singleton();
//  }
//  return instance;
//}
  //上面写法的不足是：效率过低，每次进入方法都要加锁，成本很高（包含moniter的进入和阻塞时的上下文切换）
  //显然我们只是需要在重建的时候进行同步操作（也就是写的时候），其他时候都是直接读取的，不需要同步。这就是典型写少读多了，
// 这时我们就要考虑到可见性的问题，每个线程都有自己的缓存区，修改共享变量也是在自己的缓冲区，这就可能出问题，这不volatile他来了。
public static Singleton getInstance(){
  if(instance == null){
    synchronized (Singleton.class){
      if(instance == null){
        instance = new Singleton();
      }
      return instance;
    }
  }
  return instance;

}
  public static void main(String[] args) {
//    Singleton test1 = getInstance();
//    Singleton test2 = getInstance();
//    System.out.println(test1.equals(test2));
    for(int i = 0;i<1000;i++){
      new Thread(()->{
        for(int j = 0;j<10;j++){
          Singleton test = getInstance();
          System.out.println(System.identityHashCode(test));
        }
      },"线程"+i).start();
    }
  }
}