java单例模式详解完美实现(包括反射破坏的防止和线程安全)

一.描述 
Singleton(单例)是设计模式的一种,为了保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要用途是保证某个很占系统资源的类，在同一时间只能拥有一个的情况。
例如：一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；
一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。
二.单例模式的主要特点：
1.某个类只能有一个实例；
2.必须自行创建这个实例；
3.必须自行向整个系统提供这个实例。
三.简单的具体实现：
第一种:懒汉式 (线程不安全)

 

public class SingletonDemo {
	private static SingletonDemo single = null;
	//私有的构造方法，无法主动实例化这个类
	private SingletonDemo(){}

	//静态工厂方法 通过getInstance得到具体的单例对象
	public static SingletonDemo getInstance(){
		if(single == null){
			single = new SingletonDemo(); 
		}
		return single;
	}
}

 

 

 

第二种 懒汉 线程安全

package com.hjh.Singleton;

/**
 * 
 * @author Administrator
 * 	懒汉式单例 线程安全
 *	把构造方法private 无法主动实例化Singletondemo类
 *	通过getInstance 实例化对象
 */
public class SingletonDemo {
	private static SingletonDemo single = null;
	
	private SingletonDemo(){}

	//静态工厂方法
	public static synchronized SingletonDemo getInstance(){
		if(single == null){
			single = new SingletonDemo(); 
		}
		return single;
	}
	
}

 

 

四. 反射破坏单例

看似单例好像私有了构造方法。无法访问，只能通过getInstance()得到唯一的实例对象。实际上java的反射技术可以破坏单例

public class ReflectSingleton {
	private static ReflectSingleton singleton = null;
	
	private ReflectSingleton(){};
	
	private String name = "singleton";
	
	/**
	 * 懒汉式线程安全 单例
	 */
	public static synchronized ReflectSingleton getInstance(){
		//常量写在前面可以避免一些小错误 比如 == 写成 = 
		if(null == singleton){
			singleton = new ReflectSingleton();
		}
		return singleton;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	/**
	 * 利用反射破坏单例
	 */
	public static void main(String[] args) {
		try {
			//得到构造方法
			Constructor cons = ReflectSingleton.class.getDeclaredConstructor();
			//把构造方法设为可访问 private失效
			cons.setAccessible(true);
			//利用反射实例化的单例对象
			ReflectSingleton s1 = (ReflectSingleton) cons.newInstance();
			s1.setName("s1");
			
			ReflectSingleton s2 = (ReflectSingleton) cons.newInstance();
			s2.setName("s2");
			
			//常规方法实例化的对象
			ReflectSingleton s3 = ReflectSingleton.getInstance();
			s3.setName("s3");
			
			ReflectSingleton s4 = ReflectSingleton.getInstance();
			s4.setName("s4");
			
			System.out.println("s1的name = "+s1.getName() );
			System.out.println("s2的name = "+s2.getName() );
			System.out.println("s3的name = "+s3.getName() );
			System.out.println("s4的name = "+s4.getName() );
			
		} catch (NoSuchMethodException | SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

 

最后运行结果s3的name = s4 说明s3和s4是同一个单例，

但是s1,s2却成功的创建了新的实例化对象。

这就破坏了单例模式

 

所以我们必须做出防范。

 

五.防止反射破坏的单例模式。

 

package com.hjh.Reflect;

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

/**
 * 防止反射破坏的安全单例
 */
public class SafeSingleton {

	private String name = "singleton";
	private static boolean flag = false;
	
	private SafeSingleton(){
		synchronized (this){
			//如果没有创建，就创建实例
			if(false == flag){
				flag = true;
			}else{
				throw new RuntimeException("单例对象已经创建，不能反复创建");
			}
		}
	};
	//static 在 jvm 创建时就会调用该实例化方法创建单例
	private  static class SingletonHolder{
        private static final SafeSingleton INSTANCE = new SafeSingleton();
    }
	

	public static synchronized SafeSingleton getInstance(){
		//返回这个实例化对象
		return SingletonHolder.INSTANCE;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	/**
	 * 利用反射破坏单例
	 */
	public static void main(String[] args) {
		try {
			//得到构造方法
			Constructor cons = SafeSingleton.class.getDeclaredConstructor();
			//把构造方法设为可访问 private失效
			cons.setAccessible(true);
			//利用反射实例化的单例对象
			SafeSingleton s1 = (SafeSingleton) cons.newInstance();
			s1.setName("s1");
			
			//常规方法实例化的对象
			SafeSingleton s2 = SafeSingleton.getInstance();
			s2.setName("s2");
			
		} catch (NoSuchMethodException | SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

 

结果是抛出异常 此时既然s1已经存在，就无法getInstance 或newInstance 得到s2

 

六. 进阶 --- enum枚举完美实现单例模式

 

jdk1.5以后的单例模式 里面enum实现

创建一个只有一个实例的enum 不仅可以防止反射破坏，还可以防止序列化破坏单例

写法也非常简单

public enum SingletonClass
{
    INSTANCE;
 
    public void test()
    {
        System.out.println("The Test!");
    }
}

单元素的枚举类型已经成为实现Singleton模式的最佳方法。