设计模式学习笔记——单例模式

一、饿汉式

• 类加载时就初始化得到一个单例对象，不能延时加载，调用效率高，线程安全

public class Singleton1 {
    // JVM保证任何线程访问instance静态变量之前，一定先创建此实例
    private static Singleton1 instance = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return instance;
    }
}

// 测试代码
Singleton1 s1 = Singleton1.getInstance();
Singleton1 s2 = Singleton1.getInstance();
System.out.println(s1 == s2); // true

二、懒汉式

• 延时加载，调用效率不高，线程安全

public class Singleton2 {
    private static Singleton2 instance;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        // 需要加synchronized关键字保证线程安全，迫使每个线程在进入这个方法之前，要等别的线程离开该方法
        // 如果不加可能出现某个线程A在创建此对象时，
        // 执行完下面的条件判断语句就被挂起，单例对象仍未创建，有可能出现另一个线程B在此时创建了对象
        // 线程A重新运行后又会创建一个新的对象，此时就有了两个“单例”对象
        // 缺点：同步会降低性能；而且只有第一个执行此方法时，才真正需要同步，即一旦产生实例，就不再需要同步这个方法了
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

// 测试代码
Singleton2 s1 = Singleton2.getInstance();
Singleton2 s2 = Singleton2.getInstance();
System.out.println(s1 == s2); // true

三、静态内部类

• 可以延时加载，调用效率高，线程安全

public class Singleton3 {
    private static class SingletonInstance {
        private static Singleton3 instance = new Singleton3();
    }

    private Singleton3() {
    }

    public static Singleton3 getInstance() {
        return SingletonInstance.instance;
    }
}

// 测试代码
Singleton3 s1 = Singleton3.getInstance();
Singleton3 s2 = Singleton3.getInstance();
System.out.println(s1 == s2); // true

四、枚举类

• 不能延时加载，调用效率高，线程安全，可以避免反射反序列化的漏洞

public enum Singleton4 {
    INSTANCE
}

// 测试代码
Singleton4 s1 = Singleton4.INSTANCE;
Singleton4 s2 = Singleton4.INSTANCE;
System.out.println(s1 == s2); // true

五、双重检查锁

• 可以改进Singleton2中同步效率低的缺点

public class Singleton5 {
    private volatile static Singleton5 instance;

    private Singleton5() {
    }

    public static Singleton5 getInstance() {
        // 如果实例不存在，就进入同步区，即只有第一次执行才会进入同步区
        if (instance == null) {
            synchronized (Singleton5.class) {
                if (instance == null) {
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

// 测试代码
Singleton5 s1 = Singleton5.getInstance();
Singleton5 s2 = Singleton5.getInstance();
System.out.println(s1 == s2); // true

六、几种方式的效率比较

package singleton;

import java.util.concurrent.CountDownLatch;

public class SingletonTest2 {
    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        int threadNum = 10000;
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100000; i++) {
                        Object obj = Singleton1.getInstance();
                        //Object obj = Singleton2.getInstance();
                        //Object obj = Singleton3.getInstance();
                        //Object obj = Singleton4.INSTANCE;
                        //Object obj = Singleton5.getInstance();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await(); // main线程阻塞，直至所有子线程运行结束
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

耗时比较

饿汉式	5536
懒汉式	15528
静态内部类	5742
枚举类	5248
双重检查锁	5848

七、利用反射的方法破解饿汉式单例模式

package singleton;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class SingletonTest3 {
    public static void main(String[] args) {
        try {
            // 通过反射破解直接调用私有构造器
            Class<Singleton1> clazz = (Class<Singleton1>) Class.forName("singleton.Singleton1");
            Constructor<Singleton1> c = clazz.getDeclaredConstructor(null);
            c.setAccessible(true);
            Singleton1 s1 = c.newInstance();
            Singleton1 s2 = c.newInstance();
            System.out.println(s1 == s2); // false
        } catch (InstantiationException | InvocationTargetException | NoSuchMethodException
                | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

八、反序列化方式破解饿汉式单例模式

• 如果饿汉式单例模式实现了序列化接口，还可通过反序列化方式破解饿汉式单例模式

package singleton;

import java.io.*;

public class SingletonTest4 {
    public static void main(String[] args) {
        try{
            Singleton1 s1 = Singleton1.getInstance();
            FileOutputStream fileOutputStream = new FileOutputStream("singleton1.txt");
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(s1);
            objectOutputStream.close();

            fileOutputStream.close();

            FileInputStream fileInputStream = new FileInputStream("singleton1.txt");
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            Singleton1 s2 = (Singleton1) objectInputStream.readObject();
            objectInputStream.close();
            fileInputStream.close();

            System.out.println(s1 == s2); // false
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

•  解决方法，改造Singleton1

package singleton;

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

/**
 * 实现饿汉式单例模式，并且防止反射破解和反序列化破解
 */
public class Singleton6 implements Serializable {

    // JVM保证任何线程访问instance静态变量之前，一定先创建此实例
    private static Singleton6 instance = new Singleton6();

    private Singleton6() {
        // 通过抛出异常防止反射破解单例模式
        if (instance != null) {
            throw new RuntimeException();
        }
    }

    // 反序列化时，如果定义了readResolve方法，则直接返回此方法指定的对象，而不需要重新创建对象
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }

    public static Singleton6 getInstance() {
        return instance;
    }
}

package singleton;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class SingletonTest3 {
    public static void main(String[] args) {
        try {
            // 通过反射破解直接调用私有构造器
            Class<Singleton6> clazz = (Class<Singleton6>) Class.forName("singleton.Singleton6");
            Constructor<Singleton6> c = clazz.getDeclaredConstructor(null);
            c.setAccessible(true);
            Singleton6 s1 = c.newInstance();
            Singleton6 s2 = c.newInstance();
            System.out.println(s1 == s2); // true
        } catch (InstantiationException | InvocationTargetException | NoSuchMethodException
                | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package singleton;

import java.io.*;

public class SingletonTest4 {
    public static void main(String[] args) {
        try{
            Singleton6 s1 = Singleton6.getInstance();
            FileOutputStream fileOutputStream = new FileOutputStream("singleton6.txt");
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(s1);
            objectOutputStream.close();

            fileOutputStream.close();

            FileInputStream fileInputStream = new FileInputStream("singleton6.txt");
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            Singleton6 s2 = (Singleton6) objectInputStream.readObject();
            objectInputStream.close();
            fileInputStream.close();

            System.out.println(s1 == s2); // true
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}