初学单例模式

单例模式的作用

　　就是只能创建一个对象

1.饿汉式（线程安全，因为太饿了，开始就要创建对象）

package com.xasxt.dao;
public class Singleton2 {
   //第一步：开始就创建私有的，静态的对象
  private static Singleton2 instance = new Singleton2();
  
  //第二步：私有化构造器
   private Singleton2(){}

   //第三步：静态，返回值是当前类的方法
   public static Singleton2 getInstance(){
      return instance;
   }
}

 

2.饿汉式之静态代码块（线程安全）

package com.xasxt.dao;
public class Singleton5 {
    //第一步：创建一个私有的，静态的对象
    private static Singleton5 instance ;
    //第二步：在静态代码块中给对象赋初值
    static {
        instance = new Singleton5();
    }
    //第三步：私有化构造器
    private Singleton5(){};
    
    //第四部：创建一个静态的，返回值是当前类的方法
    public static Singleton5 getInstance(){
        return instance;
    }
}

3.懒汉式（线程不安全）

package com.xasxt.dao;

public class Singleton {
   //第一步：创建一个私有的静态的变量
   private static Singleton instance;

   //第二步：构造器私有化
   private Singleton(){}

   //第三步：创建一个公共的、静态的、返回值为当前类的方法
   public static Singleton getInstance(){
      if(instance == null){
         instance = new Singleton();
      }
      return instance;
   }
}

4.懒汉式之同步方法锁（加锁之后，线程安全）

package com.xasxt.dao;

public class Singleton3 {
    //创建一个私有的，静态的对象
    private static Singleton3 instance;
    
    //第二步：构造器私有化
    private Singleton3(){};
    
    //第三步：创建一个公共的、静态的、返回值为当前类并且加锁（synchronized）的方法
    public static synchronized Singleton3 getInstacne(){
        if(instance == null){
            instance = new Singleton3();
        }
        return instance;
    }

}

5.单例模式之双重校验锁（线程安全）

package com.xasxt.dao;
public class Singleton6 {
    //第一步：创建一个有volatile修饰符的变量
    private static volatile Singleton6 instance;
    
    //第二步：构造器私有化
    private Singleton6(){};

    //第三步：创建一个公共的、静态的、返回值为当前类的方法
    public static Singleton6 getInstance(){
        if(instance == null){
            //第一次判断之后加锁
            synchronized (Singleton6.class){
                if(instance == null){
                    //第二次判断之后赋值
                    instance = new Singleton6();
                }
            }
        }
        return instance;
    }
}

6.单例模式之静态内部类（线程安全）

package com.xasxt.dao;

public class Singleton7 {
    //第一步：创建私有的静态内部类
    private static class s {
        
        //第二步，在内部类中实例化对象，变量必须是final修饰
      private static final Singleton7 instnce = new Singleton7();
  }
        //第三步：构造器私有化
        private Singleton7(){};
    
        //第四步：创建一个final修饰的方法
        public static final Singleton7 getInstnce(){
            
            //第五步：通过内部类名调用方法
            return s.instnce;
        }
}