单例模式_设计模式_java

1.饿汉式,静态常量
2.饿汉式,静态代码块
3.懒汉式,线程不安全
4.懒汉式,线程安全,同步方法
5.懒汉式,线程安全,同步代码块
6.双重检查
7.静态内部类
8.枚举
678推荐

对于频繁创建和销毁对象,用单例模式
创建对象时候耗时过多，耗费资源大
经常访问数据库,文件的对象-数据源,session工厂
对于JDK来说Runtime类用的是饿汉式
1.

public class demo01 {
  public static void main(String[] args) {
    Single s1 = Single.getInstance();
    Single s2 = Single.getInstance();
    System.out.println(s1 == s2);
    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
  }

}
class Single{
  private Single() {
    
  }
  private final static Single instance = new Single();
  
  public static Single getInstance() {
    return instance;
  }
}

public class demo02 {
//静态代码块饿汉式
  public static void main(String[] args) {
    person s1 = person.getInstance();
    person s2 = person.getInstance();
    System.out.println(s1 == s2);
    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
  }
}
class person{
  private person() {
    
  }
  private static person instance;
  static {
    instance = new person();
  }
  public static person getInstance() {
    return instance;
  }
}

public class demo03 {
  public static void main(String[] args) {
    Single1 instance = Single1.getInstance();
    Single1 instance2 = Single1.getInstance();
    System.out.println(instance == instance2);
    
    
  }
}
class Single1{
  private static Single1 instance;
  private Single1() {
    
  }
  //在用到getinstance的时候才创建instance
  public static Single1 getInstance() {
    if(instance == null) {
      instance = new Single1();
    }
    return instance;
  }
}

懒汉式,线程不安全
只可以在单线程下使用
多线程不可以满足
所以在实际开发中不可以使用

public class demo04 {
  public static void main(String[] args) {
    Single2 instance = Single2.getInstance();
    Single2 instance2 = Single2.getInstance();
    System.out.println(instance == instance2);
    
  }
}
class Single2{
  private Single2() {
    
  }
  private static Single2 instance;
  public static synchronized Single2 getInstance() {
    if(instance == null) {
      instance = new Single2();
    }
    return instance;
  }
}

懒汉式，线程安全,同步机制
带来效率低的问题,实际开发不支持用

public class demo05 {

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

懒汉式，线程安全,同步代码块
和前面的线程不安全一样

public class demo06 {
  public static void main(String[] args) {
    Single4 instance = Single4.getInstance();
    Single4 instance2 = Single4.getInstance();
    System.out.println(instance == instance2);
  }
}
class Single4{
  private Single4() {
    
  }
  private static volatile Single4 instance;
  public static Single4 getInstance() {
    if(instance == null) {
      synchronized (Single4.class) {
        if(instance == null) {
          instance = new Single4();
        }
      }
    }
    return instance;
  }
}

单例模式:双重检查:推荐使用
线程安全,延迟加载,效率高

public class demo07 {

}
class Single5{
  private Single5() {}
  private static volatile Single5 instance;
  //1
  private static class SingleInstance{
    private static final Single5 INSTANCE = new Single5();
  }
  //2.用的时候取instance
  private static Single5 getInstance() {
    return SingleInstance.INSTANCE;
  }
}

//静态内部类
//1.外部类被装载的时候,静态内部类不会立即装载
//2.也是懒汉式
//推荐使用

//1.外部类的装载不会影响内部类的装载,使得不会满装载
//2,装载内部类的时候才实例化,保证了线程安全

public class demo08 {
  public static void main(String[] args) {
    Singleton instance = Singleton.INSTANCE;
    Singleton instance2 = Singleton.INSTANCE;
    System.out.println(instance == instance2);
  }

}
//枚举实现单例
enum Singleton{
  INSTANCE;
  public void sayOK() {
    System.out.println("ok~~");
  }
}