单例模式

单例模式

概述

单例模式(创建型设计模式)定义：确保一个类在任何情况下都绝对只有一个实例，并提供一种全局的访问点

单例模式的类图：

单例模式的分类

饿汉式单例模式(静态常量)

public class SingleTon {
      private  SingleTon(){}
      /**静态常量饿汉式*/
      private  final  static   SingleTon INSTANCE =new SingleTon();
      public  static  SingleTon getInstance(){
          return  INSTANCE;
      }

    
    //Junit单元测试
      @Test
    public void test(){
        SingleTon instance = SingleTon.getInstance();
        SingleTon instance1 = SingleTon.getInstance();
        System.out.println(instance==instance1);
    }

饿汉式单例模式二（静态代码块）

public class SingleTon2 {

    private  SingleTon2(){};
    private  static  SingleTon2 instace;
    static {
        instace=new SingleTon2();
    }
    public  static SingleTon2 getInstance(){
        return  instace;
    }
}
 //Junit单元测试
      @Test
    public void test(){
        SingleTon2 instance2 = SingleTon2.getInstance();
        SingleTon2 instance3 = SingleTon2.getInstance();
        System.out.println("静态代码块方式："+(instance2==instance3));
    }

懒汉式单例模式一

public class SingleTon3 {
    private  static  SingleTon3 instance;
     private  SingleTon3(){}
    //线程不安全
    public static  SingleTon3 getInstance(){
        if (instance==null){
            instance=new SingleTon3();
        }
        return  instance;
    }

懒汉式单例模式二

  private  static  SingleTon3 instance;
     private  SingleTon3(){}
    //效率太低
    public static  synchronized SingleTon3 getInstance(){
        if (instance==null){
            instance=new SingleTon3();
        }
        return  instance;
    }

懒汉式单例模式三（推荐使用）

//volatile 轻量级 同步机制 
public  static  volatile  SingleTon3 instace;
     private  SingleTon3(){}
    //双重检查
   public  static  SingleTon3 getInstance(){
        if (instace==null){
            synchronized (SingleTon3.class){
                if (instace==null){
                    instace=new SingleTon3();
                }
            }
        }

单例模式之静态内部类

 private   SingleTon4(){}
    private  static class SingleTonInner{
        private  static  final  SingleTon4  INSANCE=new SingleTon4();
    }
    public  static SingleTon4 getInstance(){
        return  SingleTonInner.INSANCE;
    }

//在多线程的情况下
new  Thread(()->{
            SingleTon4 singleTonInner = SingleTon4.getInstance();
            System.out.println(singleTonInner);
        }).start();
        new  Thread(()->{
            SingleTon4 singleTonInner2 = SingleTon4.getInstance();
            System.out.println(singleTonInner2);
        }).start();  

单例模式之枚举

public class EnumSingleTon {
    public static void main(String[] args) {
        EnumSingleTonObject instance = EnumSingleTonObject.INSTANCE;
        EnumSingleTonObject instance2 = EnumSingleTonObject.INSTANCE;
        System.out.println(instance=instance2);//true
    }
}
enum EnumSingleTonObject{
    /**/
    INSTANCE;
    public  void  print(){
        System.out.println(this.hashCode());
    }
}

单例模式

原文：https://www.cnblogs.com/GeorgeGod/p/14090998.html