单例模式的几种实现方式

1.饿汉式

：在类加载的过程中创建单例对象。线程安全，不需要实现锁机制，效率高。不是按需创建的，可能导致加载类时间较长，浪费资源。 饿汉式：线程安全、反射不安全、反序列化不安全 (添加 readResolve 方法后安全)

饿汉式的实现代码如下：

package com.shi.test; import java.io.Serializable; //饿汉模式 public class Single1 implements Serializable{ //私有化当前类对象的实例 private static Single1 instance=new Single1(); //私有化构造方法 private Single1() {}; //对外提供的共有方法 public static Single1 getInstance() { return instance; } //防止反序列化创建新对象 public Object readResolve() { return instance; } }

测试代码 如下：

package com.shi.test; import java.lang.reflect.Constructor; import org.junit.Test; public class Single1Test { @Test public void test1() throws Exception{ //1.普通调用 Single1 s1 = Single1.getInstance(); Single1 s2 = Single1.getInstance(); //输出为true System.out.println(s1 == s2); //2.利用反射调用 Class cl = Single1.class; Constructor constructor = cl.getDeclaredConstructor(); constructor.setAccessible(true); Single1 s3 = (Single1) constructor.newInstance(); //输出为false System.out.println(s1 == s3); //3.利用反序列化调用 SerializeUtil.serializeObject(s1); Single1 s4 = (Single1) SerializeUtil.unserializeObject(); //输出为true System.out.println(s1 == s4); } }

其中的SerializeUtil定义为：

package com.shi.test; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class SerializeUtil { //用于序列化对象到文件中 public static boolean serializeObject(Object obj) { try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("a.txt")))){ out.writeObject(obj); out.flush(); out.close(); return true; } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return false; } //反序列化文件到对象中 public static Object unserializeObject() { Object obj = null; try(ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("a.txt")))){ obj = in.readObject(); in.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } return obj; } }

2.登记式(静态内部类式)

：对饿汉式的更改。单例对象不是在类加载的过程中创建，而是在调用 getInstance() 方法的时候创建的，实现了延迟加载的功能。

登记式：线程安全、反射安全(提供检查机制)、反序列化安全(提供 readResolver 方法).

登记式的实现代码为:

package com.shi.test; import java.io.Serializable; //登记式 public class Single2 implements Serializable{ private Single2() { //当instance不为空是若调用构造方法抛出异常 if(SingleHolder.instance != null) { throw new IllegalStateException(); } } //私有化静态内部类 private static class SingleHolder { //私有化静态类成员 private static Single2 instance = new Single2(); } public static Single2 getInstance() { return SingleHolder.instance; } //防止反序列化造成的数据不一致 public Object readResolve() { return SingleHolder.instance; } }

测试代码为：

package com.shi.test; import java.lang.reflect.Constructor; import org.junit.Test; public class Single2Test { @Test public void test1() throws Exception{ //1.普通调用 Single2 s1 = Single2.getInstance(); Single2 s2 = Single2.getInstance(); //输出为true System.out.println(s1 == s2); //2.反射调用 Class cl = Single2.class; Constructor constructor = cl.getDeclaredConstructor(); constructor.setAccessible(true); //会抛出异常 // Single2 s3 = (Single2)constructor.newInstance(); //3.反序列化 SerializeUtil.serializeObject(s1); Single2 s4 = (Single2) SerializeUtil.unserializeObject(); //输出为true System.out.println(s1 == s4); //4.多线程访问 for(int i=0;i<20;i++) { new Thread(new Runnable() { @Override public void run() { //输出为同一个对象 System.out.println(Single2.getInstance()); } }).start(); } //防止主程序走的太快 System.in.read(); } }

3.枚举式

：使用枚举包装类对象，枚举默认支持反射和反序列化安全。 ：当类可能有继承关系时不能使用枚举类创建单例模式。 枚举类：线程安全，反射安全，反序列化安全。

实现代码如下：

package com.shi.test; //枚举式 public enum Single3 { //相当于Single3的一个实例对象 INSTANCE{ //重写抽象方法 @Override public void doSome() { System.out.println("----doSomeing"); } }; //创建抽象方法 protected abstract void doSome(); }

测试类代码如下：

package com.shi.test; import java.lang.reflect.Constructor; import org.junit.Test; public class Single3Test { @Test public void test1() throws Exception { //1.使用一般调用 Single3 s1 = Single3.INSTANCE; Single3 s2 = Single3.INSTANCE; //输出结果为true System.out.println(s1 == s2); //2.使用反射创建新对象 Class cl = Single3.class; // Constructor constructor = cl.getDeclaredConstructor(); // constructor.setAccessible(true); // Single3 s3 = (Single3)constructor.newInstance(); //结果为抛出异常，enum默认反射安全 // System.out.println(s1 == s3); //3.使用反序列化创建对象 SerializeUtil.serializeObject(s1); Single3 s4 = (Single3) SerializeUtil.unserializeObject(); //enum默认支持反序列化安全 System.out.println(s1 == s4); } }