1.单例模式：单例模式指的是一个类只会有一个实例，即是instance，java web中Servlet就是单实例多线程的，单实例运用场景很多，例如在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例，单例的好处：节省内存，不需要new出来那么多实例；配合线程同步；一般用于公共资源。
uml关系图：
2.单例模式中设计的主要的问题：效率（同步影响效率），安全（线程安全），是否可延时（资源），是否可以避免反射和反序列化漏洞（枚举获取方式）
3.饿汉式：线程安全，效率高，在类加载时初始化不能延时加载，如果没有调用赵成资源浪费
//饿汉式:线程安全，效率高，在类加载时初始化不能延时加载，如果没有调用赵成资源浪费
public class SingletonTest1 {
private static SingletonTest1 instance = new SingletonTest1();
private SingletonTest1() {
}
public static SingletonTest1 getInstance() {
return instance;
}
}
4.懒汉式：线程安全，因为可能需要并发操作所以效率不高，可以延迟加载避免资源浪费
//懒汉式:线程安全，因为可能需要并发操作所以效率不高，可以延迟加载避免资源浪费
public class SingletonTest2 {
private volatile static SingletonTest2 instance = null;
private SingletonTest2() {
}
public static SingletonTest2 getInstance() {
if (instance == null) {
synchronized (SingletonTest2.class) {
if (instance == null) {
return instance = new SingletonTest2();
}
}
}
return instance;
}
}
5.静态内部类获取：线程安全，效率高，可以延时加载
//静态内部类获取方式:线程安全，效率高，可以延时加载
public class SingletonTest3 {
private SingletonTest3() {
}
private static class createInstance {//类似静态方法
private static SingletonTest3 instance = new SingletonTest3();
static {//没有调用静态类不会输出
System.out.println(1111);
}
}
public static SingletonTest3 getInstance() {
return SingletonTest3.createInstance.instance;
}
}
6.枚举方式获取
//枚举的方式获取:线程安全，效率高，不可以延时加载，可以避免方式和反序列化的路漏洞较为安全
public enum SingletonTest4 {
instance;
public void test(){
}
}
7.反射破解单例模式（非枚举）
public class SingletonReflectTest {
public static void main(String[] args) throws Exception {
//除了枚举，其他类似
Class<?> singletonClass = Class.forName("cn.singleton.test.SingletonTest1");
Constructor<?> declaredConstructor = singletonClass.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
SingletonTest1 instance = (SingletonTest1)declaredConstructor.newInstance();
System.out.println(instance);
}
}
防止破解方法（只能是饿汉式，对其余两种这种方法不行，初始化得到的对象和反射得到的对象不是同一个对象，假如先反射的话，就会有问题）
private SingletonTest1() {
if (instance != null) {
throw new RuntimeException();
}
}
8.反序列化破解//前提是实现了Serializable接口
public class SingletonSerializable {
@SuppressWarnings("resource")
public static void main(String[] args) throws Exception {
SingletonTest1 instance = SingletonTest1.getInstance();
// jdk8新特性,能序列化需要实现Serializable接口
try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("a.txt"))) {
objectOutputStream.writeObject(instance);
System.out.println(instance);//cn.singleton.test.SingletonTest1@55f96302
} catch (Exception e) {
e.printStackTrace();
}
Object readObject;
try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("a.txt"))) {
readObject = objectInputStream.readObject();
System.out.println(readObject);//cn.singleton.test.SingletonTest1@3d4eac69
} catch (Exception e) {
e.printStackTrace();
}
}
}
防止反序列化方法
在序列化的方法中添加如下代码（重写readObject()方法）
public SingletonTest1 readObject() {
return instance;
}
9.上述几种单例模式的效率
public class SingletonThread {
public static void test() {
// instant jdk 1.8新特性
CountDownLatch countDownLatch = new CountDownLatch(10);
long start = Instant.now().toEpochMilli();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000000; i++) {
// SingletonTest1 47
// SingletonTest2 51
// SingletonTest3 47
// SingletonTest3 48
SingletonTest1 instance2 = SingletonTest1.getInstance();
// 枚举需要接受返回值否者报错
// SingletonTest4 instance = SingletonTest4.instance;
}
countDownLatch.countDown();
}
}).start();
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = Instant.now().toEpochMilli();
System.out.println(end - start);
}
public static void main(String[] args) {
SingletonThread.test();
}
}