设计模式之单例模式

核心作用：保证一个类只有一个实例，并提供一个访问该实例的全局访问点
实现思路：懒汉式、饿汉式、双重检测锁、内部类式、枚举式

• 懒汉式：直接声明一个私有的静态类成员，然后将其构造器私有化

  • 优点：线程安全，调用效率高
  • 缺点：不能实现预加载
  • 实现过程：

  public Class LazySingleClass{
      private static instance=new LazySingleClass();
      private LazySingleClass(){}    //构造器私有化
      public static LazySingleClass getInstance(){
          return instance;
      }
  }
  

• 饿汉式:只是声明一个私有的静态类，但不进行初始化，第一次使用的时候进行初始化，要加上同步字段

  • 优点：线程安全，调用效率高，可以实现预加载
  • 缺点：
  • 实现过程：

   public Class HungrySingleClass{
       private static instance;
       private HungrySingleClass(){}
       public static HungrySingleClass getInstance(){
          if(instance==null){
              instance=new HungrySingleClass();
           } 
           return instance;
       }
   }
  

• 双层检测锁：

  • 优点：
  • 缺点：由于jvm优化的问题，在使用的过程中可能会出错
  • 实现过程

   /**
   * 双重检测锁
   * 该模式将同步加到了if后边提高了调用的效率，但是偶然会出现问题
   * @author Admain
   *
   */
  public class DoubleLock {
  private  DoubleLock() {	}
  private static DoubleLock instance;
  public static synchronized DoubleLock getInstance(){
  	//检测两次instance是否为null
  	if(instance==null){ //第一次检查
  	synchronized (DoubleLock.class) {
  		if(instance==null){
  			instance=new DoubleLock();//第二次检查
  		}
  		}	
  	}
  	return instance;
  }
  }
  }  
  

• 内部类方式：通过内部类持有对象来实现单例模式

  • 优点：线程安全，调用效率高，可以延时加载
  • 代码实现

  public class StaticInnerClass {
  private StaticInnerClass(){}
  //内部类天然线程安全，没有同步代码块效率高
  private static class innerClass{
  	private static final StaticInnerClass instance=new StaticInnerClass(); 
  }
  public static StaticInnerClass getInstance(){
  	return innerClass.instance;
  }
  }  
  

• 枚举方式实现：定义枚举类型，然后在枚举类体内添加需要的方法

  • 优点：利用了枚举天然单例的的特点，线程安全，调用效率高，可以延时加载
  • 代码实现：

  public enum EnumStyle {
  //则个枚举元素，本身就是一个单例模式,但是不能延时加载，可以天然防止反射和反序列化的漏洞
  instance;
  //添加自己所需要的操作
  public void operation(){
     System.out.println("操作单例对象");
  }
  }