彻底搞懂单例模式
前情提要:
- 饿汉式、懒汉式、静态内部类?蜻蜓点水
- volatitle关键字禁止指令重排之JMM内存模型?重在理解看不见
- 反射破坏单例?
- 枚举实现单例,反射无法破坏?
什么是单例模式:
百度百科:是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。
应用场景:
- 操作系统的任务管理器,因为同一台电脑无法同时打开两个任务管理器界面。
- 程序的日志系统,因为如果同时有两个程序维护日志文件,日志内容无法追加。
- web应用中配置文件的读取,因为配置文件是共享资源,非单例会创建多个相同的资源对象浪费系统内存、CPU等的性能。
- 垃圾回收机制。
- 线程池和连接池的实现。
以上可以看出,单例模式的应用场景:
共享资源的访问使用单例,如配置信息、日志信息等,避免建立多个相同的对象浪费系统资源
控制资源的访问使用单例,如线程池、连接池等,方便对于访问的资源进行控制。
实现套路:
- 构造方法私有化
- 提供一个静态方法获取对象实例
饿汉式-可用
- 优点:简单方便,避免多线程问题
- 缺点:类加载的时候完成初始化,如果未使用会在成内存浪费
//饿汉式,容易造成内存浪费
class HungrySingle{
//模拟内存浪费
private static Byte[] a = new Byte[1024*1000];
private HungrySingle(){
System.out.println(Thread.currentThread().getName());
}
//默认直接初始化对象实例
private static final HungrySingle instance = new HungrySingle();
public static HungrySingle getInstance(){
return instance;
}
}
测试:启动30个线程,构造方法只会执行一次。为避免内存浪费可以再实际调用的时候再初始化实例对象,因此下面的懒汉式应运而生。
静态内部类
//静态内部类
class StaticInnerClassSingle{
private StaticInnerClassSingle(){}
private static class StaticInnerClassSingleInstance {
private static StaticInnerClassSingle singleton = new StaticInnerClassSingle();
}
public static StaticInnerClassSingle getInstance(){
return StaticInnerClassSingleInstance.singleton;
}
}
懒汉式-不可用
- 优点:无
- 缺点:只能在单线程下使用
//懒汉式,线程不安全
class LazySingle{
private LazySingle(){
System.out.println(Thread.currentThread().getName());
}
//默认不初始化,调用的时候再初始化
private static LazySingle instance;
public static LazySingle getInstance(){
if(instance== null){
instance = new LazySingle();
}
return instance;
}
}
测试:多线程调用出现多次调用构造器,因此改进为加synchronized关键字。
懒汉式-同步代码块-不可用
忽略同步方法模式,直接使用同步代码块,粒度更小
//懒汉式,同步代码块
class LazySyncSingle{
private LazySyncSingle(){
System.out.println(Thread.currentThread().getName());
}
private volatile static LazySyncSingle instance;
public static LazySyncSingle getInstance(){
if(instance== null){
synchronized (LazySyncSingle.class){
instance = new LazySyncSingle();
}
}
return instance;
}
}
测试:多线程下调用创建实例不能保证安全,假如一个线程进入了if 判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。
懒汉式-DCL-可用
//懒汉式,加锁双重校验
class LazySyncDoubleCheckSingle{
private LazySyncDoubleCheckSingle(){
System.out.println(Thread.currentThread().getName());
}
private static LazySyncDoubleCheckSingle instance;
public static LazySyncDoubleCheckSingle getInstance(){
//第一次校验
if(instance== null){
//class模板全局唯一
synchronized (LazySyncDoubleCheckSingle.class){
//第二次校验
if(instance== null){
//不是原子操作指令重排会导致对象虚化
instance = new LazySyncDoubleCheckSingle();
}
}
}
return instance;
}
}
测试:多线程下结果和预期一致,只会调用一次构造器。
但是instance = new LazySyncDoubleCheckSingle()并不是一个原子操作,先研究下创建一个字符串执行了什么。
/**
* @author my
*/
public class MySingle {
public static void main(String[] args) {
String str = new String("a");
}
}
找到class文件直接javap -c MySingle.class
一个对象的创建需要经历0 6 9 三个步骤,在一些极端情况下当线程1执行到0发生指令重排,指令9和6位置互换,即对象已经建立了关联关系但是并未执行6的init,此时线程2进来第一个if判断是否为null,此时已经不为null了,直接把创建了一半的对象返回了,这就是安全所在,要验证这个抱歉电脑太差模拟不出来,因此为了避免这种不安全的情况引入volatile关键字保证jvm在执行时不会发生指令重排。
JMM内存模型:
volatile:在编译期间,会在生成指令序列的时候,会在一些禁止重排序的地方,插入内存屏障从而禁止操作系统对指令进行重排序。
懒汉式-DCL+volatile-推荐
//懒汉式,加锁双重校验,禁止指令重排
class LazySyncDoubleCheckVolatitleSingle{
private LazySyncDoubleCheckVolatitleSingle(){
System.out.println(Thread.currentThread().getName());
}
//禁止指令重排
private static volatile LazySyncDoubleCheckVolatitleSingle instance;
public static LazySyncDoubleCheckVolatitleSingle getInstance(){
if(instance== null){
synchronized (LazySyncDoubleCheckVolatitleSingle.class){
if(instance== null){
instance = new LazySyncDoubleCheckVolatitleSingle();
}
}
}
return instance;
}
}
反射破坏单例
/**
* @author my
*/
public class MySingle {
public static void main(String[] args) throws Exception {
Constructor<LazySyncDoubleCheckVolatitleSingle> declaredConstructor =
LazySyncDoubleCheckVolatitleSingle.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
LazySyncDoubleCheckVolatitleSingle instance1 = declaredConstructor.newInstance();
LazySyncDoubleCheckVolatitleSingle instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
测试:因此上面所讲的单例在一定程度上都是不可用的。
那么我们要如何去避免这种情况呢?
枚举
/**
* @author my
*/
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws Exception {
System.out.println(EnumSingle.INSTANCE);
System.out.println(EnumSingle.INSTANCE);
}
}
测试:两次生成的对象一样单例ok
反射破坏枚举单例
/**
* @author my
*/
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws Exception {
Constructor<EnumSingle> declaredConstructor =
EnumSingle.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
//NoSuchMethodException: com.example.studyjuc.EnumSingle.<init>()
System.out.println(declaredConstructor.newInstance());
}
}
查看源码:应该报错是Cannot reflectively create enum objects才对呀
@CallerSensitive
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, null, modifiers);
}
}
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) {
ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
反编译刚才那个类
javap -p EnumSingle.class
这里看到是有这个无参构造器但是为什么报错说没有呢?
说明这个反编译还是不是很理想,用jad反编译,发现有一个有参的构造器
jad -sjava EnumSingle.class
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: EnumSingle.java
package com.example.studyjuc;
public final class EnumSingle extends Enum
{
public static EnumSingle[] values()
{
return (EnumSingle[])$VALUES.clone();
}
public static EnumSingle valueOf(String name)
{
return (EnumSingle)Enum.valueOf(com/example/studyjuc/EnumSingle, name);
}
//这个是什么,是有参的构造器呀
private EnumSingle(String s, int i)
{
super(s, i);
}
public EnumSingle getInstance()
{
return INSTANCE;
}
public static final EnumSingle INSTANCE;
private static final EnumSingle $VALUES[];
static
{
INSTANCE = new EnumSingle("INSTANCE", 0);
$VALUES = (new EnumSingle[] {
INSTANCE
});
}
}
修改反射
class Test{
public static void main(String[] args) throws Exception {
Constructor<EnumSingle> declaredConstructor =
EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
//NoSuchMethodException: com.example.studyjuc.EnumSingle.<init>()
System.out.println(declaredConstructor.newInstance());
}
}
测试:因此发现枚举的单例是无法被破坏