java 单例模式实现代码

目录

• 1、使用静态内部类实现
• 2、使用枚举实现
• 3、序列化与反序列化

1、使用静态内部类实现

使用静态内部类实现单例模式，线程安全

class SingletonStaticInner {
        private SingletonStaticInner() {}
        private static class SingletonInner {
		private static SingletonStaticInner singletonStaticInner = new SingletonStaticInner();
	}

	public static SingletonStaticInner getInstance() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return SingletonInner.singletonStaticInner;
	}
}

2、使用枚举实现

class Resource{}

public enum SomeThing {
    INSTANCE;
    private Resource instance;
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

3、序列化与反序列化

单例模式被破坏解决方式：

如下代码，序列化和反序列化的情况下会出现生成多个对象的情况，违背了单例模式。

public class Test {

	public static void main(String[] args) {
		try {
			Ssi serialize = Ssi.getInstance();
			System.out.println(serialize.hashCode());
			//序列化
			FileOutputStream fo = new FileOutputStream("tem");
			ObjectOutputStream oo = new ObjectOutputStream(fo);
			oo.writeObject(serialize);
			oo.close();
			fo.close();
			//反序列化
			FileInputStream fi = new FileInputStream("tem");
			ObjectInputStream oi = new ObjectInputStream(fi);
			Ssi serialize2 = (Ssi) oi.readObject();
			oi.close();
			fi.close();
			System.out.println(serialize2.hashCode());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

//使用匿名内部类实现单例模式，在遇见序列化和反序列化的场景，得到的不是同一个实例
//解决这个问题是在序列化的时候使用readResolve方法，即去掉注释的部分
class Ssi implements Serializable {

	private static final long serialVersionUID = 1L;

	private static class InnerClass {
		private static Ssi ssi = new Ssi();
	}

	public static Ssi getInstance() {
		return InnerClass.ssi;
	}

//	protected Object readResolve() {
//		System.out.println("调用了readResolve方法");
//		return InnerClass.singletonStaticInnerSerialize;
//	}
}

解决办法就是在反序列化中使用readResolve()方法（将上面的注释代码去掉就可以了）