单例模式的饿汉式和懒汉式

单例模式：保证一个类只有一个对象

饿汉式：

//饿汉式 保证一个类只有一个对象
public class HungerSingleton {
     

    private static HungerSingleton hungerSingleton = new HungerSingleton();
    
    private HungerSingleton(){
     
        System.out.println("创建对象");
    }

    public static HungerSingleton getInstance(){
     
        return hungerSingleton;
    }

    public static void main(String[] args) {
     
        for (int i = 0; i < 1000; i++) {
     
            new Thread(()->{
     
                System.out.println(HungerSingleton.getInstance());
            }).start();
        }
    }
}

懒汉式：

1.同步方法： 同步方法，作用域大，但是性能低

//懒汉式
public class LazySingleton {
     
    private static  LazySingleton lazySingleton =null;

    public LazySingleton() {
     
        System.out.println("创建对象");
    }

    //同步方法，作用域大，但是性能低
    public static synchronized LazySingleton getInstance(){
     
        if(lazySingleton==null){
     //可能同时有多个线程进行判断
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }

    public static void main(String[] args) {
     
        long l1 = System.currentTimeMillis();
        for (int i = 0; i <100 ; i++) {
     
            new Thread(()->{
     
                System.out.println(LazySingleton.getInstance());
            }).start();
        }
        long l2 = System.currentTimeMillis();
        System.out.println("所用时间"+(l2-l1));
    }
}

2.同步代码： 作用域小，但是性能高

//懒汉式
public class LazySingleton {
     
    private static  LazySingleton lazySingleton =null;

    public LazySingleton() {
     
        System.out.println("创建对象");
    }


  //同步代码
     public static  LazySingleton getInstance(){
     
         synchronized (LazySingleton.class) {
     
             if (lazySingleton == null) {
     //可能同时有多个线程进行判断
                 lazySingleton = new LazySingleton();
             }
         }
        return lazySingleton;
    }

    public static void main(String[] args) {
     
        long l1 = System.currentTimeMillis();
        for (int i = 0; i <100 ; i++) {
     
            new Thread(()->{
     
                System.out.println(LazySingleton.getInstance());
            }).start();
        }
        long l2 = System.currentTimeMillis();
        System.out.println("所用时间"+(l2-l1));
    }
}

3.同步代码的基础上提高性能

//懒汉式
public class LazySingleton {
     
    private static volatile  LazySingleton lazySingleton =null;

    public LazySingleton() {
     
        System.out.println("创建对象");
    }

    //升级版
      public static  LazySingleton getInstance(){
     
          if(lazySingleton==null) {
      //提升性能，对象不为空就跳过同步块
              synchronized (LazySingleton.class) {
     
                  if (lazySingleton == null) {
     //可能同时有多个线程进行判断
                      lazySingleton = new LazySingleton();
                  }
              }
          }
        return lazySingleton;
    }


    public static void main(String[] args) {
     
        long l1 = System.currentTimeMillis();
        for (int i = 0; i <100 ; i++) {
     
            new Thread(()->{
     
                System.out.println(LazySingleton.getInstance());
            }).start();
        }
        long l2 = System.currentTimeMillis();
        System.out.println("所用时间"+(l2-l1));
    }
}