实现单例模式的多种方法

1.立即加载 -- “饿汉模式”

　立即加载就是使用类的时候已经将对象创建完毕。
  测试代码如下：

 public class Singleton {
　　private static Singleton instance=new Singleton();
   private Singleton(){}
   public static Singleton getInstance(){
       /*
        * 此代码为立即加载，缺点是不能有其他实例变量
        * 因为getInstance()方法没有同步
        * 所以有可能出现非线程安全问题
        */
       return instance;
   }
 }
 

 public class Run {
　　public static void main(String[] args) {
    　　MyThread t1=new MyThread();
    　　MyThread t2=new MyThread();
    　　MyThread t3=new MyThread();
    
    　　t1.start();
    　　t2.start();
    　　t3.start();
　　}

}

 public class MyThread extends Thread {
　　@Override
　　public void run() {
    　　// TODO Auto-generated method stub
    　　System.out.println(Singleton.getInstance().hashCode());
　　}
 }
 

以上的Run类和MyThread类在本文测试前四种方法一样，接下来就不在重复编码。
  运行结果如下：

2.延迟加载 -- “懒汉模式”

延迟加载就是在调用getXXX方法时，实例才会被创建。

2.1 普通“懒汉模式”

  测试代码如下：

public class Singleton {
　　private static Singleton instance;
   private Singleton(){}
   public static Singleton getInstance(){
    　try {
   　　　　if (instance == null) {
    　　　 // 模拟在创建对象过程中有准备工作
    　　　　Thread.sleep(2000);
    　　　　instance = new Singleton();
    　　  }
 　　  } catch (InterruptedException e) {
      　　// TODO Auto-generated catch block
      　　e.printStackTrace();
 　　  }
 　　  return instance;
   }

}

此种方式，在多线程的环境下将无法实现单例。
运行结果如下：

2.2 线程安全下的“懒汉模式”

（1）使用synchronize关键字

测试代码如下：

public class Singleton {
　　private static Singleton instance;

　　private Singleton() {
 　}

   synchronized public static Singleton getInstance() {
   　　try {
      　　if (instance == null) {
         　　// 模拟在创建对象过程中有准备工作
         　　Thread.sleep(2000);
         　　instance = new Singleton();
         }
       } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
       }
    　　return instance;
   }            

 }
 

运行结果：

此方法虽然可以解决线程安全问题，但是对整个方法进行加锁无疑会使整个方法的运行效率大大降低。

（2）尝试同步代码块

测试代码如下：

 

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
         try {
               synchronized (Singleton.class) {

                    if (instance == null) {
                         // 模拟在创建对象过程中有准备工作
                        Thread.sleep(2000);
                        instance = new Singleton();
                    }
               }
          } catch (InterruptedException e) {
                // TODO Auto-generated catch block
               e.printStackTrace();
          }
          return instance;
    }

 }
 

运行结果：

此方法虽然也是可以解决线程安全问题，但是它的运行效率和上一个方法的运行效率差不多，也是会大大拉低程序的效率

（3）针对某些重要的代码进行单独的同步

测试代码如下:

  public class Singleton {
  　　private static Singleton instance;

  　　private Singleton() {
   　}

     public static Singleton getInstance() {
　　　　　try {
  　　　　　　　if (instance == null) {
   　　　　　　　　// 模拟在创建对象过程中有准备工作
   　　　　　　　　Thread.sleep(2000);
   　　　　　　　　synchronized (Singleton.class) {
     　　　　　　  　　instance = new Singleton();
   　　　　　　　　}
  　　　　　　 }
 　　　　 } catch (InterruptedException e) {
      　　　　// TODO Auto-generated catch block
      　　　　e.printStackTrace();
 　　　　 }
 　　　　　return instance;
   　　}

}
  

运行结果：

此方法虽然大幅度的解决了程序效率问题，但是却无法解决线程安全问题

（4）使用DCL双检查锁机制

测试代码如下：

public class Singleton {
 private volatile static Singleton instance;

 private Singleton() {
 }

 public static Singleton getInstance() {
   try {
      if (instance == null) {
      // 模拟在创建对象过程中有准备工作
      Thread.sleep(2000);
      synchronized (Singleton.class) {
   if(instance==null)
       instance = new Singleton();
       }
        }
   } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
   return instance;
  }

 }
 

public class Singleton {
　　private volatile static Singleton instance;

　　private Singleton() {
　　}

　　public static Singleton getInstance() {
   　　try {
      　　if (instance == null) {
      　　　　// 模拟在创建对象过程中有准备工作
      　　　　Thread.sleep(2000);
      　　　　synchronized (Singleton.class) {
   　　　　　　　　if(instance==null)
       　　　　　　　　instance = new Singleton();
       　　　　}
     　　 }
   　　} catch (InterruptedException e) {
     　　　　// TODO Auto-generated catch block
     　　　　e.printStackTrace();
   　　}
   　　return instance;
　　}

}
 

运行结果如下：

此方法即完美解决了效率问题，也解决了线程安全问题，在懒汉模式下的最佳方法

3.使用静态内置类实现

测试代码如下：

public class Singleton{

　　private static class SigntonHandle{
　　　　private static final Singleton instance=new Singleton();
　　}

　　private Singleton(){}

　　public static Singleton getInstance(){
    　　return SigntonHandle.instance;
　　}

 } 

运行结果：

 

由运行结果可知此方法可以实现单例模式，并且无线程安全问题，但是如果遇到序列化对象的时候，默认的运行方式就不是单例的

4.使用static块实现

public class Singleton{
    private static Singleton instance=null;
        static{
        instance=new Singleton();
        }
    private Singleton(){}
    
    public static Singleton getInstance(){
        return instance;
    }
}

运行结果：

 

由运行结果可知此方法可以实现单例模式，并且无线程安全问题。

5.使用序列化和反序列化实现

测试代码如下：

public class Singleton implements Serializable{
    
    private static final long serialVersionUID = 1L;

    private static class SigntonHandle{
        private static final Singleton instance=new Singleton();
    }
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        return SigntonHandle.instance;
    }
    
    protected Object readResolve(){
        System.out.println("已調用readResolve方法");
        return SigntonHandle.instance;
    }

   }

public class SaveAndRead {
    public static void main(String[] args) {
        try{
            Singleton instance=Singleton.getInstance();
            
            FileOutputStream fos=new FileOutputStream(new File("MyObject.txt"));
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            oos.writeObject(instance);
            oos.close();
            fos.close();
            System.out.println(instance.hashCode());
        }catch(Exception e){
            e.printStackTrace();
        }
        try{
            FileInputStream fis=new FileInputStream(new File("MyObject.txt"));
            ObjectInputStream ois=new ObjectInputStream(fis);
            Singleton instance1=(Singleton) ois.readObject();
            ois.close();
            fis.close();
            System.out.println(instance1.hashCode());
        }catch(Exception e){
            e.printStackTrace();
        }
    }

   }

运行结果：

 

若注释调Singleton类中的readResolve方法,则运行结果如下：

 

由运行结果可知此方法可以实现单例模式，并且无线程安全问题，并且解决了在序列化对象中出现不是单例的情况。

6.使用enum枚举数据类型实现

此方法还含有MyThread类和Run类和之前的一致。
测试代码如下：

public class Singleton{
    public enum EnumSingleton{
        singleton;
        private Singleton instance;
        private EnumSingleton(){
            instance=new Singleton();
        }
        public Singleton getInstance(){
            return instance;
        }
    }

    public static Singleton getInstance(){
        return EnumSingleton.singleton.getInstance();
    }

   }

运行结果：

由运行结果可知此方法可以实现单例模式，并且无线程安全问题。