设计模式之单例模式

单例模式

核心作用

• 保证一个类中只有一个实例，并且提供一个访问该实例的全局访问点 
• 项目中的配置文件，一般也只有一个对象，没必要每次都都new一遍，配置文件不容易改变
• Spring中bean的加载，以及控制器对象也是单例模式 

单例模式五种实现方式

• 饿汗式：编程安全，调用效率高。但是不能延时加载
• 懒汉式：线程安全，调用效率不高，但是可以延时加载
• 双重检测锁式（由于JVM底层内部模型原因，偶尔出现问题，不建议使用）
• 静态内部类式：线程安全，调用效率高，但是可以延时加载
• 枚举单例：线程安全，调用效率高，不能延时加载

代码

 

 饿汗式 ：线程安全的，类初始化时立即加载，天然线程安全

 

public class SingleEHan {
    private static SingleEHan instance = new SingleEHan(); //类实例化，立即加载                                          //，天然线程安全
    private SingleEHan(){} //单例模式构造器方法必须私有
    public static SingleEHan getInstance(){  //不需要同步，显然调用的效率高
        return instance;
    }
}

Compiled from "SingleEHan.java"
public class com.xhd.admin.web.SingleEHan {
  public static com.xhd.admin.web.SingleEHan getInstance();
    Code:
       0: getstatic     #2  // Field instance:Lcom/xhd/admin/web/SingleEHan;
       3: areturn

  static {};
    Code:
       0: new           #3  // class com/xhd/admin/web/SingleEHan
       3: dup
       4: invokespecial #4  // Method "<init>":()V
       7: putstatic     #2  // Field instance:Lcom/xhd/admin/web/SingleEHan;
      10: return
}

 

 

 懒汉式加载 资源利用效率高，但调用效率低

 

public class SingleLanHan {

    private static SingleLanHan singleLanHan;
    private SingleLanHan(){
        if(singleLanHan != null){    //防止反射
            throw new RuntimeException();
        }
    }

   // synchronized 调用效率低
    public static synchronized SingleLanHan getSingleLanHan(){  
        if(singleLanHan == null){
            singleLanHan = new SingleLanHan();
        }
        return singleLanHan;
    }
}

 

  静态内部类实现方式：，线程安全调用效率高 懒加载

 

public class SingleStatic {
    private SingleStatic() {}
    //静态内部类
    private static class SingleStaticInstance{
        private static final SingleStatic instance 
                                 = new SingleStatic();
    }
    public static SingleStatic getInstance(){
        return SingleStaticInstance.instance;
    }
}


Compiled from "SingleStatic.java"
public class com.xhd.admin.web.SingleStatic {
  public static com.xhd.admin.web.SingleStatic getInstance();
    Code:
       0: invokestatic  #3                  
// Method com/xhd/admin/web/SingleStatic$SingleStaticInstance.access$100:()Lcom/xhd/admin/web/SingleStatic;
       3: areturn

  com.xhd.admin.web.SingleStatic(com.xhd.admin.web.SingleStatic$1);
    Code:
       0: aload_0
       1: invokespecial #1                  // Method "<init>":()V
       4: return
}

 

枚举：天然线程安全，天然实例唯一

public enum SingleEnum {

    //这个枚举元素，本身就是单例对象
    INSTANCE;
    //添加自己需要的操作
    public void singletonOperation(){

    }
}

双重检查锁实现单例模式

public class SingleDoubleCheck {

    private static SingleDoubleCheck singleDoubleCheck = null;
    private SingleDoubleCheck(){}

    public static SingleDoubleCheck getSingleDoubleCheck(){
        if(singleDoubleCheck == null){
            SingleDoubleCheck sc ;
            synchronized (SingleDoubleCheck.class){
                sc = singleDoubleCheck;
                if(sc == null){
                    sc = new SingleDoubleCheck();
                }
            }
            singleDoubleCheck = sc;
        }
        return singleDoubleCheck;
    }
}

多线程环境下测试用CountDownLatch

• 同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待
• countDown() 当前线程调此方法，则统计减一，建议放在finally里执行
• await方法：调用此方法会一直阻塞当前线程，直到计数器的值为0 

public class ClientTest {

    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        int threadNum = 10;
        final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        for(int j = 0; j< threadNum;j++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i<1000000;i++){
                        Object o = SingleEHan.getInstance(); //换方式在此地方
                        countDownLatch.countDown();
                    }
                }
            }).start();
        }

        countDownLatch.await();  //await 自动检测
        long end = System.currentTimeMillis();
        long between = end - start;
        System.out.println("总耗时："+between);
    }
}

 

序列化与反序列化问题，以及反射问题

public class SingleLanHanSerial implements Serializable{
    private static SingleLanHanSerial singleLanHan;
    private SingleLanHanSerial(){
        if(singleLanHan != null){    //防止反射
            throw new RuntimeException();
        }
    }
    public static synchronized SingleLanHanSerial getSingleLanHan(){  
                                           // synchronized 调用效率低
        if(singleLanHan == null){
            singleLanHan = new SingleLanHanSerial();
        }
        return singleLanHan;
    }

// 反序列化，如果定义了readResolve方法，就直接返回Instance实例，防止了反序列化的漏洞
    private Object readResolve() throws ObjectStreamException {
        return singleLanHan;
    }
}

 

反射测试序列化测试

public class ClientEnum {
    public static void main(String[] args) throws Exception {
        //通过反射机制创造对象
        Class<SingleLanHan> lanHanClazz = (Class<SingleLanHan>)Class.forName("com.jenny.mole.single.SingleLanHan");
        Constructor<SingleLanHan> constructor = lanHanClazz.getDeclaredConstructor(null);
        constructor.setAccessible(true); //可以访问私有方法了这样
        SingleLanHan singleLanHan = constructor.newInstance();
        SingleLanHan singleLanHan1 = constructor.newInstance();
        System.out.println(singleLanHan);
        System.out.println(singleLanHan1);

//        通过反序列化的方式创造对象
        SingleLanHanSerial single2 = SingleLanHanSerial.getSingleLanHan();
        FileOutputStream fos = new FileOutputStream("/d:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(single2);

        ObjectInputStream ois = new
                       ObjectInputStream(new FileInputStream("/d:/a.txt"));
        SingleLanHanSerial s3 = (SingleLanHanSerial)ois.readObject();

        System.out.println(single2);
        System.out.println(s3);

    }
}

 

 

静态内部类

外部类没有static属性，则不会像懒汉式那样立即加载对象只有真正调用getInstance，才会加载静态内部类，加载类时时线程安全的，Instance是static final类型，保证了内存中只有一个实例存在，而且只能被赋值一次，从而保证了线程安全性兼备了并发高效调用和延迟加载的优势

 

枚举方式

• 优点：实现简单，枚举本身就是单例模式，由JVM从根本上提供保障，避免通过反射和反序列化的漏洞
• 缺点：无延迟加载

如何选用

• 单例对象，占用资源少，不需要延时加载：枚举好于 懒汉式
• 单例对象占用资源大，需要延时加载：静态内部类好于懒汉式