Java设计模式学习笔记，一：单例模式

　　开始学习Java的设计模式，因为做了很多年C语言，所以语言基础的学习很快，但是面向过程向面向对象的编程思想的转变还是需要耗费很多的代码量的。所有希望通过设计模式的学习，能更深入的学习。

　　把学习过程中的笔记，记录下来，只记干货。

第一部分：单例模式的内容

　　单例模式：类只能有一个实例。

　　类的特点：1、私有构造器；2、内部构造实例对象；3、对外提供获取唯一实例的public方法。

　　常见的单例模式实现有五种形式：

　　　　1、饿汉式。

　　　　2、懒汉式。

　　　　3、双重检查锁式。

　　　　4、静态内部类式。

　　　　5、枚举式。

　　以下分别介绍：

　　一、饿汉式

　　　　饿汉式单例特点：线程安全，不能延时加载，效率较高。

 public class SingletonDemoE {

     //内部构建唯一实例
     private static SingletonDemoE instance = new SingletonDemoE();

     //私有化构造器
     private SingletonDemoE(){

     }

     //公共静态方法获取唯一实例化对象
     public static SingletonDemoE getInstance(){
         return instance;
     }

 }

　　二、懒汉式

　　　　懒汉式单例特点：线程安全（须synchronized做方法同步），可以延时加载，效率较低。

 public class SingletonDemoL {

     //声明实例对象
     private static SingletonDemoL instance;

     //私有化构造器
     private SingletonDemoL(){

     }

     //公共静态方法获取唯一实例化对象，方法同步
     public static synchronized SingletonDemoL getInstance(){
         if(instance == null){
             //第一次实例化时构建
             instance = new SingletonDemoL();
         }
         return instance;
     }

 }    

　　三、双重检查锁式

　　　　结合了饿汉式和懒汉式的优点，但由于JVM底层内部模型原因，偶尔会出问题，所以不建议使用，本文不赘语。

　　四、静态内部类式

　　　　静态内部类式单例特点：线程安全（须synchronized做方法同步），可以延时加载，效率较高。

 public class SingletonDemoJ {

     //静态内部类
     private static class SingletonClassInstance {
         private static final SingletonDemoJ instance = new SingletonDemoJ();
     }

     //私有化构造器
     private SingletonDemoJ(){

     }

     //公共静态方法获取唯一实例化对象，方法同步
     public static synchronized SingletonDemoJ getInstance(){
         return SingletonClassInstance.instance;
     }

 }

　　五、枚举式

　　　　枚举式单例特点：枚举是天然的单例，线程安全，不可延时加载，效率较高

 public enum SingletonDemoM {
     //枚举元素，本身就是单例模式
     INSTANCE;

     //实现自己的操作
     public void singletonOperation(){

     }
 }

第二部分：单例模式的破解（扩展）

　　单例模式的五种实现方式中，除枚举式是天然的单例不可破解之外，其他四种形式均可通过反射和反序列化的机制进行破解。

　　以懒汉式单例为例，首先分别看一下如何通过反射和反序列化的机制破解单例。

　　定义一个常规的懒汉式单例：

 public class SingletonDemoAntiCrackL {
     private static SingletonDemoAntiCrackL instance;

     private SingletonDemoAntiCrackL(){

     }

     public static synchronized SingletonDemoAntiCrackL getInstance(){
         if(instance == null){
             instance = new SingletonDemoAntiCrackL();
         }
         return instance;
     }
 }

　　正常我们创建多个单例的实例，都应该是同一个对象，如下测试Demo：

 public class TestCrackDemo {
     public static void main(String[] args) {
         SingletonDemoAntiCrackL sL1 = SingletonDemoAntiCrackL.getInstance();
         SingletonDemoAntiCrackL sL2 = SingletonDemoAntiCrackL.getInstance();
         System.out.println("sL1 = " + sL1);
         System.out.println("sL2 = " + sL2);
     }
 }

　　运行返回：

sL1 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL2 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55

　　利用反射机制破解单例，创建多个不同的实例：

 package com.corey.singleton;

 import java.lang.reflect.Constructor;

 public class TestCrackDemo {
     public static void main(String[] args) {
         SingletonDemoAntiCrackL sL1 = SingletonDemoAntiCrackL.getInstance();
         SingletonDemoAntiCrackL sL2 = SingletonDemoAntiCrackL.getInstance();
         System.out.println("sL1 = " + sL1);
         System.out.println("sL2 = " + sL2);

         //利用反射机制破解单例
         try {
             Class<SingletonDemoAntiCrackL> clazz = (Class<SingletonDemoAntiCrackL>)Class.forName("com.corey.singleton.SingletonDemoAntiCrackL");
             Constructor<SingletonDemoAntiCrackL> c = clazz.getDeclaredConstructor(null);
             c.setAccessible(true); //跳过权限检查，可以访问私有属性和方法
             SingletonDemoAntiCrackL sL3 = c.newInstance(null);    //构建实例
             SingletonDemoAntiCrackL sL4 = c.newInstance(null);
             System.out.println("sL3 = " + sL3);
             System.out.println("sL4 = " + sL4);

         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

　　运行返回：

sL1 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL2 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL3 = com.corey.singleton.SingletonDemoAntiCrackL@15db9742
sL4 = com.corey.singleton.SingletonDemoAntiCrackL@6d06d69c

　　可见，通过反射构建的sL3和sL4两个对象，都是不同的实例，破解了单例模式只能有一个实例的要求。

　　那么，修改单例的构造函数，可以应对反射机制的破解，代码如下：

 public class SingletonDemoAntiCrackL {
     private static SingletonDemoAntiCrackL instance;

     private SingletonDemoAntiCrackL(){
         //私有构造器，增加实例检查，若已创建实例，则抛出异常
 6         if(instance != null){
 7             throw new RuntimeException();
 8         }
     }

     public static synchronized SingletonDemoAntiCrackL getInstance(){
         if(instance == null){
             instance = new SingletonDemoAntiCrackL();
         }
         return instance;
     }
 }

　　此时，在运行TestCrackDemo时，会抛出java.lang.reflect.InvocationTargetException异常，避免了通过反射机制创建多个实例的问题。

　　接下来，看下通过反序列化机制破解单例。

　　当单例的类实现了Serializable接口时，就可以通过反序列化机制破解，如下单例：

 public class SingletonDemoAntiCrackL implements Serializable{
     private static SingletonDemoAntiCrackL instance;

     private SingletonDemoAntiCrackL(){
         //私有构造器，增加实例检查，若已创建实例，则抛出异常
         if(instance != null){
             throw new RuntimeException();
         }
     }

     public static synchronized SingletonDemoAntiCrackL getInstance(){
         if(instance == null){
             instance = new SingletonDemoAntiCrackL();
         }
         return instance;
     }
 }

　　反序列化破解测试Demo：

 package com.corey.singleton;

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.lang.reflect.Constructor;

 public class TestCrackDemo {
     public static void main(String[] args) {
         SingletonDemoAntiCrackL sL1 = SingletonDemoAntiCrackL.getInstance();
         SingletonDemoAntiCrackL sL2 = SingletonDemoAntiCrackL.getInstance();
         System.out.println("sL1 = " + sL1);
         System.out.println("sL2 = " + sL2);

         //通过反序列化机制破解单例
         try {
             //序列化，将对象存入文件
             FileOutputStream fos = new FileOutputStream("f:/fos.txt");
             ObjectOutputStream oos = new ObjectOutputStream(fos);
             oos.writeObject(sL1);
             oos.close();
             fos.close();
             //反序列化，从文件中读出对象
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f:/fos.txt"));
             SingletonDemoAntiCrackL sL5 = (SingletonDemoAntiCrackL)ois.readObject();
             System.out.println("sL5 = " + sL5);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

　　运行的结果：

sL1 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL2 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL5 = com.corey.singleton.SingletonDemoAntiCrackL@33909752

　　可见，反序列化出来的实例对象，是不同的对象，即单例已被破解。

　　解决版本，单例类中重写readResolve方法，可以应对反射机制的破解，代码如下：

 package com.corey.singleton;

 import java.io.ObjectStreamException;
 import java.io.Serializable;

 /**
  * 单例模式，懒汉式
  * 线程安全，能延时加载，效率相对较低
  * @author Corey
  *
  */
 public class SingletonDemoAntiCrackL implements Serializable{
     private static SingletonDemoAntiCrackL instance;

     private SingletonDemoAntiCrackL(){
         //私有构造器，增加实例检查，若已创建实例，则抛出异常
         if(instance != null){
             throw new RuntimeException();
         }
     }

     public static synchronized SingletonDemoAntiCrackL getInstance(){
         if(instance == null){
             instance = new SingletonDemoAntiCrackL();
         }
         return instance;
     }

     private Object readResolve() throws ObjectStreamException{
         //反序列化时，直接返回对象
         return instance;
     }
 }

　　修改后，再次运行TestCrackDemo，可以看到反序列化后，构建的仍然是同一个对象。

sL1 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL2 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55
sL5 = com.corey.singleton.SingletonDemoAntiCrackL@2a139a55

第三部分：单例模式各个实现方式的效率

　　采用如下代码，测试：

 package com.corey.singleton;

 import java.util.concurrent.CountDownLatch;

 /**
  * 测试单例模式的效率
  * @author Corey
  *
  */
 public class TestEfficiencyDemo {
     public static void main(String[] args) throws Exception {

         int threadNum = 10;
         long start = System.currentTimeMillis();

         final CountDownLatch cdl = new CountDownLatch(threadNum);

         //创建10个线程
         for(int k=0; k<threadNum; k++){
             new Thread(new Runnable() {

                 @Override
                 public void run() {
                     //每个线程构建100万个实例对象
                     for(int i=0; i<1000000; i++){
                         Object o = SingletonDemoE.getInstance();
                     }
                     //每个线程运行完毕，线程计数器减一
                     cdl.countDown();
                 }
             }).start();
         }

         cdl.await();//main线程阻塞，直到现场计数器为0，才继续执行。

         long end = System.currentTimeMillis();
         System.out.println("饿汉式总耗时：" + (end - start));
     }
 }

　　运行结果：

饿汉式总耗时：17

　　以此类推，测试各个实现方式的单例的效率。注意，此处根据电脑性能以及电脑的运行情况不同，结果都是不一样的，甚至同一实现方式，多次运行的结果也不一样。

　　我这里的测试结果如下：

饿汉式总耗时：17
懒汉式总耗时：171
静态内部类式总耗时：165
枚举式总耗时：11

　　以上就是设计模式中的单例模式！