单例模式在实践中的应用 Singleton Pattern

本文主要是介绍单例模式在实践中的应用 Singleton Pattern，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. 编写工具类

将构造方法声明为私有，并且可以抛出错误防止反射

/*** 日期工具类* @author chaowendao*/
public class DateUtil {/*** 私有构造方法并且防止反射*/private DateUtil() {throw new Error("防止反射");}/*** 获得当前系统时间* @return*/public static Timestamp getCurrentTime(){return new Timestamp(System.currentTimeMillis());}// 略

以下是未进行错误抛出时的反射攻击

	/*** 反射再重新构造一个实例* @throws Exception*/@Testpublic void test02() throws Exception {// 获得默认构造器Constructor<DateUtil> c = DateUtil.class.getDeclaredConstructor();// 跳过安全检查c.setAccessible(true);DateUtil util = (DateUtil) c.newInstance();DateUtil util2 = (DateUtil) c.newInstance();assertNotEquals(util, util2);}

2. 编写常量类

常量类可以用三种方式来表示，interface , 常规类，枚举

interface，不需要声明public static final 修饰符，默认表示为常量类

public interface Constant {String COMPLETE = "COMPLETE";String YES = "Y";int OFFSET = 0;String ORDER = "UPDATED_TIME";
}

常规类，使用final修饰符避免继承

public final class CodeConstant {public static final String  REGEX = "^[0_9]{8}$";public static final int CORE_POOL_SIZE = 10;public static final int MAXIMUN_POOL_SIZE = 30;public static final int KEEP_ALIVE_TIME = 60 * 1000;public static final int BLOCK_QUEUE_SIZE = 1000;
}

枚举，天生可以防止反射攻击(并且线程安全)的常量类，数量控制在64个以内

public enum DataSource {MASTER,SLAVER;
}

3. 使用静态内部类来实现单例模式(推荐)

public class Instance {/*** 构造器私有化*/private Instance() {}/*** 静态内部类*/private static class Inner  {/*** 静态内部类中的静态变量*/private static final Instance INSTANCE = new Instance();}/*** 方法调用时候才占用内存* 多线程并发时，不存在排队问题*/public static Instance getInstance(){return Inner.INSTANCE;}
}

4. 饿汉式的方式实现单例模式(推荐)

public class HungrInstance {/*** 初始化时即将单例加到内存中*/private static final HungryInstance INSTANCE = new LazyInstance();public static LazyInstance getInstance() {return INSTANCE;}
}

5. 其他比较麻烦的方法

懒汉式加载，多线程时候可能创建多个实例(可以加上同步锁进行部分改善)

public class LazyInstance {private LazyInstance() {}private static LazyInstance instance = null;/*** 在需要的时候进行实例创建，多线程时可能创建多个*/public static LazyInstance getInstance() {if (null == instance) {instance = new LazyInstance();}return instance;}
}

双重锁实现(DCK) ，锁造成的开销大

public class DCKInstance {/*** 1.5以前的版本 volatile编译指令不起作用，可能导致高并发失效，1.5以后的OK*/private static volatile DCKInstance instance = null;private DCKInstance() {}public static DCKInstance getInstance() {if (null == instance) {synchronized (DCKInstance.class) {instance = new DCKInstance();}}return instance;}
}

容器单例模式

public class ContainerInstance {/*** 线程安全的HashMap*/private static final Map<String, Object> MAP =  new ConcurrentHashMap<>();public static void putObject(String key, Object instance) {if (null != key && !"".equals(key) && null != instance) {// 保证一个实例if (! MAP.containsKey(key)) {MAP.put(key, instance);}}}/*** 取出容器中存储的单例*/public static Object getInstance(String key) {return MAP.get(key);}
}

线程局部变量实现方式

public class ThreadInstance {/*** 线程局部变量*/private static final ThreadLocal<ThreadInstance> LOCAL = new ThreadLocal<ThreadInstance>();private static ThreadInstance instance = null;public static ThreadInstance getInstance() {// 第一次线程调用时执行if (null == LOCAL.get()) {synchronized (ThreadInstance.class) {if (null == instance) {instance = new ThreadInstance();}}// 将存在或者新建的单例存入线程局部变量中LOCAL.set(instance);}return LOCAL.get();}
}

单例模式实现列举：

实现方式	优点	缺点
饿汉模式	简单方便(推荐)	大量单例时消耗内存
懒汉模式	需要时加载	高并发下容易创建多个实例
懒汉模式(加锁)	需要时加载	高并发下可能创建多个实例，锁开销大
双重锁模式	并发安全	锁开销大，1.5版本以前可能失效
静态内部类模式	方便(推荐)	实现时多写一个类
枚举模式	防止反射攻击并且线程安全，支持反序列化	实例的类型是枚举，需要转换
容器模式	可以存储多个单例	占内存，可能存在覆盖问题
线程局部变量模式	线程安全	实现相对复杂