设计模式-01-单例模式

110 阅读2分钟

单例模式还是特别特别重要的一个模式,代码比较简单,主要是利用静态属性选择加载时机,以及对重复加载做一个判断!!!!!!!!!

单例模式有好几种:首先分为懒汉式和饿汉式

  1. 首先是饿汉式:直接生产对象
public class Hungry{
    private byte[] data=new byte[1024*1024];
    private byte[] data1=new byte[1024*1024];
    private byte[] data2=new byte[1024*1024];
    
    private Hungry(){
    
    }
    
    //一开始就创建对象,占用内存空间
    private final static Hungry hungry=new Hungry();
    
    public static Hungry getInstance(){
        return hungry;
    }
}
  1. 懒汉式:需要的时候在生产;
public class Lazyman{

        //单线程下可以,但是多线程会有很多问题
    private static Lazyman lazyman;
   
    private Hungry(){
    
    }
    
    //一开始就创建对象,占用内存空间
    private final static Hungry hungry=new Hungry();
    
    public static Hungry getInstance(){
        if(Lazyman==null){
           lazyman=new Lazyman();                     
        }
         return lazyman; 
        
    }
}

3.DCL懒汉式(存在问题,多线程下)

public class Lazyman{

        //单线程下可以,但是多线程会有很多问题
    private static Lazyman lazyman;
   
    private Hungry(){
    
    }
    
    //一开始就创建对象,占用内存空间
    private final static Hungry hungry=new Hungry();
    
    public static Hungry getInstance(){
        if(Lazyman==null){
            synchronized(lazyman.class){
                 if(Lazyman==null){
                     lazyman=new Lazyman();     
                     /*
                     1.分配内存
                     2.执行构造方法
                     3.对象指向这个空间
                     //有可能会发生1.2.3指令重拍,所以要避免
                     
                     */
                 }

            }
                             
        }
         return lazyman; 
        
    }
}

4.双重检测 votile模式

public class Lazyman{

        //单线程下可以,但是多线程会有很多问题
    private voletile static Lazyman lazyman;
   
    private Hungry(){
    
    }
    
    //一开始就创建对象,占用内存空间
    private final static Hungry hungry=new Hungry();
    
    public static Hungry getInstance(){
        if(Lazyman==null){
            synchronized(lazyman.class){
                 if(Lazyman==null){
                     lazyman=new Lazyman();     
                     /*
                     1.分配内存
                     2.执行构造方法
                     3.对象指向这个空间
                     //有可能会发生1.2.3指令重拍,所以要避免
                     
                     */
                 }

            }
                             
        }
         return lazyman; 
        
    }
}

5.通过反射,来获取对象;

public class Lazyman{

        //单线程下可以,但是多线程会有很多问题
    private voletile static Lazyman lazyman;
    
    //这个地方是重点!!!!!!!!!!!!!
    private Hungry(){
        synchronized(lazyman.class){
            if(lazyman!=null){
                throw new RuntimeException("不要试图反射获取类方法");
            }
        
        }
    
    }
    
    //一开始就创建对象,占用内存空间
    private final static Hungry hungry=new Hungry();
    
    public static Hungry getInstance(){
        if(Lazyman==null){
            synchronized(lazyman.class){
                 if(Lazyman==null){
                     lazyman=new Lazyman();     
                     /*
                     1.分配内存
                     2.执行构造方法
                     3.对象指向这个空间
                     //有可能会发生1.2.3指令重拍,所以要避免
                     
                     */
                 }

            }
                             
        }
         return lazyman; 
        
    }
}

6:使用枚举

`

public enum EnumSingle(){
    INSTANCE;
    
    punlic EnumSingle getInstance(){
        return INSTANCE;  
    
    }
    

}

`