Java中的单例模式实例分析

本篇内容介绍了“Java中的单例模式实例分析”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

1、定义

单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
隐藏其所有的构造方法。
属于创建型模式。

2、适用场景

确保任何情况下都绝对只有一个实例。

3、常见写法

第一种：饿汉式单例：在单例类首次加载时就创建实例

public class HungrySingleton {    private static final HungrySingleton INSTANCE = new HungrySingleton();        private HungrySingleton() {    }        public static HungrySingleton getInstance() {        return INSTANCE;    }}

饿汉式单例静态代码块写法：

public class HungryStaticSingleton {    private static final HungryStaticSingleton INSTANCE;        static {        INSTANCE = new HungryStaticSingleton();    }        private HungryStaticSingleton() {    }        public static HungryStaticSingleton getInstance() {        return INSTANCE;    }}

第二种：懒汉式单例：被外部类调用时才创建实例

public class LazySingleton {    private static LazySingleton INSTANCE = null;        private LazySingleton() {    }        public static LazySingleton getInstance() {        if (INSTANCE == null) {            INSTANCE = new LazySingleton();        }        return INSTANCE;    }}

懒汉式单例静态匿名内部类写法(性能最优)：

public class LazyInnerClazzSingleton implements Serializable {        private LazyInnerClazzSingleton() {    }        public static final LazyInnerClazzSingleton getInstance() {        return LazyHolder.INSTANCE;    }    private static class LazyHolder {        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();    }}

第三种：注册式单例：将每一个实例都缓存到统一的容器中，使用唯一标识获取实例

注册式单例枚举写法：

public enum EnumSingleton {    INSTANCE;        private Object data;    public Object getData() {        return data;    }    public void setData(Object data) {        this.data = data;    }    public static EnumSingleton getInstance() {        return INSTANCE;    }}

Spring中常见的注册式单例写法：

public class ContainerSingleton {        private static Map<String, Object> container = new ConcurrentHashMap<>();    private ContainerSingleton() {    }    public static Object getBean(String clazzName) {        // 加synchronized代码块保证线程安全        synchronized (container) {            if (!container.containsKey(clazzName)) {                Object object = null;                try {                    object = Class.forName(clazzName).newInstance();                    container.put(clazzName, object);                } catch (Exception e) {                    e.printStackTrace();                }                return object;            }            return container.get(clazzName);        }    }}

第四种：ThreadLocal线程单例：保证线程内部的全局唯一，且天生线程安全

public class ThreadLocalSingleton {    public static final ThreadLocal<ThreadLocalSingleton> THREAD_LOCAL = new ThreadLocal<ThreadLocalSingleton>() {        @Override        protected ThreadLocalSingleton initialValue() {            return new ThreadLocalSingleton();        }    };    private ThreadLocalSingleton() {    }    public static ThreadLocalSingleton getInstance() {        return THREAD_LOCAL.get();    }}

4、如何防止单例被破坏

1.多线程破坏单例以及解决方法

以懒汉式单例LazySingleton为例：

首先写一个线程实现类，如下：

import com.hzg.study.design.pattern.singleton.lazy.LazySingleton;public class ExecutorThread implements Runnable {    @Override    public void run() {        LazySingleton instance = LazySingleton.getInstance();        System.out.println(Thread.currentThread().getName() + ":" + instance);    }}

main方法测试：

public class LazySingletonTest {    public static void main(String[] args) {        Thread thread1 = new Thread(new ExecutorThread());        thread1.start();        Thread thread2 = new Thread(new ExecutorThread());        thread2.start();        System.out.println("----------------------------------------");    }}

测试结果：显然出现了两个不同的实例

解决方法1：加synchronized关键字修饰getInstance方法

public class LazySingleton {    private static LazySingleton INSTANCE = null;        private LazySingleton() {    }        public static synchronized LazySingleton getInstance() {        if (INSTANCE == null) {            INSTANCE = new LazySingleton();        }        return INSTANCE;    }}

解决方法2：双重检查锁DoubleCheck

public class LazyDoubleCheckSingleton {        private volatile static LazyDoubleCheckSingleton INSTANCE = null;        private LazyDoubleCheckSingleton() {    }        public static LazyDoubleCheckSingleton getInstance() {        if (INSTANCE == null) {            synchronized (LazyDoubleCheckSingleton.class) {                if (INSTANCE == null) {                    INSTANCE = new LazyDoubleCheckSingleton();                }            }        }        return INSTANCE;    }}

2.反射破坏单例以及解决方法

以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：

main方法测试：

public class LazyInnerClazzSingletonTest {    public static void main(String[] args) {        try {            Class<LazyInnerClazzSingleton> aClazz = LazyInnerClazzSingleton.class;            Constructor<LazyInnerClazzSingleton> declaredConstructor = aClazz.getDeclaredConstructor(null);            declaredConstructor.setAccessible(true);            LazyInnerClazzSingleton instance1 = declaredConstructor.newInstance();            LazyInnerClazzSingleton instance2 = LazyInnerClazzSingleton.getInstance();            System.out.println(instance1);            System.out.println(instance2);            System.out.println(instance1 == instance2);        } catch (Exception e) {            e.printStackTrace();        }    }}

测试结果：构建了两个不同的实例

解决方法：在构造器中增加如下if判断

public class LazyInnerClazzSingleton implements Serializable {        private LazyInnerClazzSingleton() {        if (null != LazyHolder.INSTANCE) {            throw new RuntimeException("不允许构建多个实例");        }    }        public static final LazyInnerClazzSingleton getInstance() {        return LazyHolder.INSTANCE;    }    private static class LazyHolder {        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();    }}

再次测试：

3.序列化破坏单例以及解决方法

以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：注意必须先实现序列化接口Serializable

main方法测试：

    public static void main(String[] args) {        LazyInnerClazzSingleton instance1 = LazyInnerClazzSingleton.getInstance();        LazyInnerClazzSingleton instance2 = null;        try (                FileOutputStream fileOutputStream = new FileOutputStream("LazyInnerClazzSingleton.obj");                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);                FileInputStream fileInputStream = new FileInputStream("LazyInnerClazzSingleton.obj");                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);        ) {            // 序列化            objectOutputStream.writeObject(instance1);            objectOutputStream.flush();            // 反序列化            instance2 = (LazyInnerClazzSingleton) objectInputStream.readObject();            System.out.println(instance1);            System.out.println(instance2);            System.out.println(instance1 == instance2);        } catch (Exception e) {            e.printStackTrace();        }    }

测试结果：构建了两个不同的实例

解决方法：新增readResolve方法

public class LazyInnerClazzSingleton implements Serializable {        private LazyInnerClazzSingleton() {        if (null != LazyHolder.INSTANCE) {            throw new RuntimeException("不允许构建多个实例");        }    }        public static final LazyInnerClazzSingleton getInstance() {        return LazyHolder.INSTANCE;    }    private static class LazyHolder {        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();    }        private Object readResolve() {        return LazyHolder.INSTANCE;    }}

5、优缺点

优点：

在内存中只有一个实例，减少了内存开销。
可以避免对资源的多重占用。
设置全局访问点，严格控制访问。

缺点：

没有接口，扩展困难。
如果要扩展单例对象，只有修改代码，没有其他途径。
不符合开闭原则

“Java中的单例模式实例分析”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！