线程安全的单例模式

• 单例模式的构造器是私有的 声明变量是私有的 只有返回是公开的
• public方法一定是静态的 因为我们不能通过对象获得方法 只能通过类名
  为了保证线程安全：
• 我们的类是final的做到方法不被子类覆盖 导致多个线程同时访问
• 类中的变量为了保证线程安全都用static 因为类加载的时候初始化静态变量 jvm对于类加载阶段是线程安全的
• 多个线程去访问一个方法的时候记得加锁

懒汉模式的volatile

• 为什么不全部同步 如果已经有了对象就不用进入临界区这样性能高过每一次都加锁
• 为什么多一次判断 为了避免第一次创建对象的时候t2进入创建重复
• 在执行反编译的过程当中发现很多时候我们去方法种取对象的时候 因为jvm的指令优化导致 对象还没创建成功就被取走了 为了保证有序性 要在声明变量出加volatile

pubic final class Singleton
{
 private Singleton(){} //构造器私有
 private static volatile Sigleton INSTANCE =null; //静态有序性的变量
 public static Singleton getInstance()
 {
   if(INSTANCE!=null){return  INSTANCE;}
   synchronized(Singleton.class) //第一次创建INSTANCE时 t1进入 t2等待
   {
    if(INSTANCE!=null){return  INSTANCE;}//t2进入发现t1已经创建 无需再出创
    INSTANCE=new Sigleton();//t1进入 
    return INSTANCE;
   }
 }
}

懒汉模式 之 静态内部类

• 为什么要用静态内部类呢。首先内部类不被外界随意获得这是单例
• 其次静态类是类加载的 而类加载是懒惰的 当使用这个类才开始加载

public final class Singleton
{
 private Singleton(){};
  private static class LazyLoader
  {
   static final Singleton INSTANCE=new Singleton();
  }
  public static  Sigleton getInstance()
  {
  return LazyLoader.INSTANCE;
  }
}

懒汉模式普通

• 放在方法上是每一个次来取对象 都要进行一次重量级的锁么？ 性能是不是消耗？

public final class Singleton
{
private Singleton(){};
private static final Sigleton INSTANCE=null;
public static synchronized Sigelton getInstance()
{
 if(INSTANCE!=null){return INSTANCE;}
 INSTANCE=new Sigleton();
 return INSTANCE;
 }
}

饿汉模式

public final class Singleton implements Serializable
{
private Singleton(){};
private static Singleton INSTANCE=new Singleton();//直接就生成对象
public static Singleton getInstance(){return INSTANCE;}
public Object readResolve(){return INSTANCE;}
}

枚举

• 枚举单例是防止反序列化 甚至 反射 对单例的破坏
• 枚举属于饿汉模式 也是类一加载 单例对象就被创建

enum Singleton
{
INSTANCE;
}