单例模式--笔记

单例模式是一种对象创建型模式，使用单例模式，可以保证一个类只能唯一的生成一个实例化对象

GoF对单例模式的定义：保证在一个类中，只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

在应用开发系统中，我们常常需要以下需求：

1).在多线程之间，如servlet环境，共享同一个资源或者操作同一个对象

2).在整个程序空间启用全局变量，共享资源

3).大规模系统中，为了性能的考虑，需要节省对象的创建时间等等

因为Singleton模式可以保证为一个类只生成唯一的一个实例对象，所以对于上述情况，Singleton模式就派上用场了。

单例模式实现：

1.饿汉式；

2.懒汉式；

3.双重检查

一般实现：

public class Person{
   
    priate String name;
   
    public String getName（）{
     
      return name；
     } 
    public String setName（）{
     
      return this.name=name；
     } 
   
   
   }

 

主类：

public class MainClass{
  public static void main(String[] args){
    
    Person per=new Person();
    Person per2=new Person();
    //定义变量
    per.setName("张三")；
    per2.setName（“李四”）；
    //通过person类生成了两个对象
    System.out.println(per.getName());
    System.out.println(per2.getName());

  }
}

此时，在非单例模式下，定义两个对象，得到了输出结果为：

张三

李四

首先展示的是饿汉式：

public class Person{
   
    priate String name;
    public static final Person person =new person（）；//饿汉式设置
     //
    public String getName（）{
     
      return name；
     } 
    public String setName（）{
     
      return this.name=name；
     } 
    //构造函数私有化
    private person(){
   
   }
   //构造一个全局的静态方法：因为如果不是全局的，那么需要通过对象来进行调用，如果定义成全局的静态，就可以通过类来调用
   public static Person getPerson(){
     return new Person();
      }
   }

此时，对于主类修改为：

public class MainClass{
    public static void main(String[] args){
    Person per=Person.getPerson();//不再使用new来定义对象，用类定义
    Person per2=Person.getPerson();
     //定义变量
     per.setName("张三");
     per2.setName("李四");
    //通过person类生成了两个对象
     System.out.println(per.getName());
     System.out.println(per2.getName());
 
   }
 }

得到的结果为：

李四

李四

懒汉式：

public class Person{
    
   priate String name;
    private static Person person;//静态初始化默认为null
     public String getName（）{
      return name；
      } 
    public String setName（）{
      
       return this.name=name；
      } 
     //构造函数私有化
     private person(){    
    }
    public static Person getPerson(){
    //此处添加一个判断
     if(person==null)   person=new  Person;     
      return  person();
       }
    }

结果为：

李四

李四

上述两种情形各有所长，在饿汉式中，一加载Person类就进行初始化对象，保证同一个对象

在上述懒汉式中，可以保证单线程正常单例模式

允许多线程的懒汉式单例模式：

public class Person{
   
    priate String name;
    private static Person person;//静态初始化默认为null
      public String getName（）{
       return name；
       } 
    public String setName（）{
      
        return this.name=name；
      } 
      //构造函数私有化
      private person(){    
     }
    //使用一个全局的静态方法，使用同步方式
     public static Synchrogazed Person getPerson(){
    //当有一个线程进来时，这个方法就被霸占了，对于进来的方法就是将执行完毕在允许其他线程进入
      if(person==null)  //第一步
         person=new  Person;  //   第二步
       return  person();//第三步  
       }
     }

双重检查：

  原因：在上述的多线程代码段中，我们实现的是将整个方法都实现同步，

 经过思考，我们可以发现，对于只有第一次的时候才会执行if内的内容；整个方法锁死后，接下来第二次，第三次。。。进来的都要进行判断if语句，影响执行效率

 

  public class Person{
     
      priate String name;
      private static Person person;//静态初始化默认为null
        public String getName（）{
         return name；
         } 
      public String setName（）{
        
         return this.name=name；
       } 
       //构造函数私有化
       private person(){    
      }
     //使用一个全局的静态方法
      public static  Person getPerson(){
     //当有一个线程进来时，这个方法就被霸占了，对于进来的方法就是将执行完毕在允许其他线程进入
       if(person==null) { //第一步
          Synchrogazed（Person.class）{//仅仅同步化这一部分
          if(person==null)//这个判断语句添加的原因 当有两个线程进来时，第一个线程和第二个线程都执行完 
             // if(person==null)这条语句，第一个线程进入同步，第二个线程等待，当第一个线程执行完，
             //return之后，第二个线程又会执行同步语句，及时第一个线程已经new了一个对象，所以为防止这个情况的发生，
             //需要在同步里边再判断一次，也就是第二次判断
          person=new  Person();}
         }  //   第二步
        return  person();//第三步  
        }
      }