JAVA设计模式:单例模式

Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍二种：懒汉式单例、饿汉式单例。

单例模式Singleton
 * 应用场合:有些对象只有一个就够了，如皇帝和老婆

 1. Windows的Task Manager（任务管理器）

   2. windows的Recycle Bin（回收站）

   3. 数据库连接池的设计一般也是采用单例模式

   ..............

 * 作用:保证整个应用程序中，某个实例有且只有一个

 

饿汉模式

public class Singleton {
	//饿汉模式->在类加载的时候，它的实例就加载了(private static Singleton instance=new Singleton())
	//将构造方法私有化，不允许外界直接创造对象
	private Singleton(){
		
	}
	//在类的内部创建一个唯一实例
	private static Singleton instance=new Singleton();
	
	//提供一个获取实例的方法
	public static Singleton getInstance(){
		return instance;
	}
	
}

 

懒汉模式

public class Singleton2 {
	//1.将构造方法私有化，不允许外部直接创建对象
	private Singleton2(){
		
	}
	//2.声明类的唯一实例，使用private static修饰
	private static Singleton2 instance;
	
	//3.提供一个获取实例的方法，使用public static修饰
	public static Singleton2 getInstance(){
		if(instance==null){
			instance=new Singleton2();
		}
		return instance;
	}
}

测试:

public static void main(String[] args) {
		//饿汉模式
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		if(s1==s2){
			System.out.println("s1和s2是同一个实例");
		}else{
			System.out.println("s1和s2不是同一个实例");
		}
		//懒汉模式
		Singleton2 s3=Singleton2.getInstance();
		Singleton2 s4=Singleton2.getInstance();
		if(s3==s4){
			System.out.println("s3和s4是同一个实例");
		}else{
			System.out.println("s3和s4不是同一个实例");
		}
	}

结果是

"s1和s2是同一个实例“

”s3和s4是同一个实例“

但是以上懒汉模式的实现没有考虑线程安全的问题，在并发情况下可能出现多个Singleton实例，可以加上synchronized，不过最好加在getInstance方法里面

public static Singleton2 getInstance() {  
        if (instance == null) {    
            synchronized (Singleton2.class) {    
               if (instance == null) {    
                  instance = new Singleton2();   
               }    
            }    
        }    
        return instance;   
    }  

synchronized 写在方法上，为什么效率低？
在N个线程同时都在getInstance的情况下，如果synchronized 加在方法上，那么每次getInstance都需要加锁，解锁。
意味着：获取该类的实例对象时，N个线程都必须排队，一个个等着获取锁。

 

 

为什么synchronized写在里面，要判断两次instance是否为空？

假设程序刚启动，同时100个线程，都在拿instance，这时候，instance还没实例化，运行在最前面的5个线程A,B,C,D,E，因为instance == null
他们都运行到了的if (instance == null)大括号内，同步代码块前。ABCDE，5个线程中的一个“幸运儿D"，拿到了锁内代码的执行权（cpu给它分配了时间片），而其他4线程，A,B,C,E个只能在同步代码块外面等候，“幸运儿D"，进入代码块后，再次判断instance==null？
发现instance确实没被创建，为null，于是new操作创建instance，拿到了instance，返回，并且把“锁”释放。
剩下的A,B,C,E，也一个一个进入同步代码块，与D不同的是，他们在锁内的判断中都发现instance不等于null，
(很显然同步代码快里面如果没有再次判断，instance会被创建5次...)
不需要new操作，直接拿。


至于剩下的95个线程，他们在instance被创建之后，
才走到第一个判断 if (instance == null) 这里，
这时候，他们发现instance不等于null，已经被创建了
他们都不需要经过同步代码快，所以效率高。 

======================以下为2019/3/28更新内容===============================

通过枚举实现单例模式，可以有效防范反射、反序列化攻击，这也是effective java这本书中强力推荐的！

public enum  ValidateCodeType {

    /**
     * 短信验证码
     */
    SMS {
        @Override
        public String getParamNameOnValidate() {
            return SecurityConstants.DEFAULT_PARAMETER_NAME_CODE_SMS;
        }
    },
    /**
     * 图片验证码
     */
    IMAGE {
        @Override
        public String getParamNameOnValidate() {
            return SecurityConstants.DEFAULT_PARAMETER_NAME_CODE_IMAGE;
        }
    };

    /**
     * 校验时从请求中获取的参数的名字
     * @return
     */
    public abstract String getParamNameOnValidate();

}

上面是一个简单的枚举类，它有两个变量一个是图片验证码，一个是短信验证码

相信大部分人平时都是很简单的应用enum，这样的写法可能很多人还没见过，现在我们用户jad反编译工具查看下反编译结果！

public abstract class ValidateCodeType extends Enum
{

    public static ValidateCodeType[] values()
    {
        return (ValidateCodeType[])$VALUES.clone();
    }

    public static ValidateCodeType valueOf(String name)
    {
        return (ValidateCodeType)Enum.valueOf(com/wlj/security/core/validate/code/ValidateCodeType, name);
    }

    private ValidateCodeType(String s, int i)
    {
        super(s, i);
    }

    public abstract String getParamNameOnValidate();


    public static final ValidateCodeType SMS;
    public static final ValidateCodeType IMAGE;
    private static final ValidateCodeType $VALUES[];

    static
    {
        SMS = new ValidateCodeType("SMS", 0) {

            public String getParamNameOnValidate()
            {
                return "smsCode";
            }

        }
;
        IMAGE = new ValidateCodeType("IMAGE", 1) {

            public String getParamNameOnValidate()
            {
                return "imageCode";
            }

        }
;
        $VALUES = (new ValidateCodeType[] {
            SMS, IMAGE
        });
    }
}

ValidateCodeType是一个抽象类继承了Enum,只有一个私有构造函数(不能在外部被调用)，这符合单例模式的定义，另外还定义一个抽象方法以及两个ValidateCodeType类型的静态final修饰的变量

这两个变量在static代码块中被初始化（饿汉模式），赋值匿名内部类实例的引用（使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的）

既然是继承了外部的抽象类，就要实现它的抽象方法，