JAVA设计模式之单例模式

最新推荐文章于 2020-04-16 07:10:18 发布

杰酷

最新推荐文章于 2020-04-16 07:10:18 发布

阅读量516

点赞数

分类专栏： android 文章标签： android 单例模式

本文链接：https://blog.csdn.net/jk17640/article/details/41011815

版权

android 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

本文对网络上各种单例模式的解释加以总结，添加了一些个人的注解。希望对光大初学者有所帮助。

来源：

http://blog.csdn.net/jason0539/article/details/23297037

http://blog.csdn.net/tanyujing/article/details/14160941

http://www.360doc.com/content/14/0608/16/17791378_384840282.shtml

概念：

　　java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。其中登记式单例模式是GoF为了解决懒汉式和饿汉式单例模式均不可继承的缺点设计的。只是他的子类实例化的方式只能是懒汉式。

一. 单例模式优缺点：

主要优点：

1、提供了对唯一实例的受控访问。

2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

3、允许可变数目的实例。

主要缺点：

1、由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。

2、单例类的职责过重，在一定程度上违背了“单一职责原则”。

3、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

　　二. 单例模式有一下特点：
　　 1、单例类只能有一个实例。
　　2、单例类必须自己自己创建自己的唯一实例。

　　3、单例类必须给所有其他对象提供这一实例。

三.单例模式的应用场景：

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager 吗？不信你自己试试看哦~

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因此用单例模式来维护，就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule 都共享一个HttpApplication实例.

总结以上，不难看出：

　　单例模式应用的场景一般发现在以下条件下：

　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

首先看一个经典的单例实现（经典单例模式存在反射和线程安全两个隐患。后期将对反射和线程安全进行讲解）。

[java]view plaincopyprint? 
   
 public class Singleton {  
     private static Singleton uniqueInstance = null;  
    
     private Singleton() {  
        // Exists only to defeat instantiation.  
     }  
    
     public static Singleton getInstance() {  
        if (uniqueInstance == null) {  
            uniqueInstance = new Singleton();  
        }  
        return uniqueInstance;  
     }  
     // Other methods...  
 }  

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）

但是以上实现没有考虑线程安全问题。所谓线程安全是指：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。或者说：一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。显然以上实现并不满足线程安全的要求，在并发环境下很可能出现多个Singleton实例。

三种单例模式：

/**
 * //懒汉式单例类.在第一次调用的时候实例化
 * 
 * @author mobile
 * 
 */
public class SingleTon {
	private static SingleTon mSingleTon = null;

	// 私有的构造子
	private SingleTon() {

	}

	// 考虑线程安全。方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
	public synchronized static SingleTon getInstance() {
		if (mSingleTon == null) {
			mSingleTon = new SingleTon();
		}
		return mSingleTon;
	}
}

/**
 * 饿汉式单例类，类初始化时，自行实例化
 * 
 * @author mobile
 * 
 */
public class SingleTon1 {
	private SingleTon1() {

	}

	private static SingleTon1 mSingleTon = new SingleTon1();

	public static SingleTon1 getInstance() {
		return mSingleTon;
	}
}

/**
 * 登记式单例类. 类似Spring里面的方法，将类名注册，下次从里面直接获取。
 * 
 * @author mobile
 * 
 */
public class SingleTon2 {
	private static HashMap<String, SingleTon2> map = new HashMap<String, SingleTon2>();
	static {
		SingleTon2 mSingleTon2 = new SingleTon2();
		map.put(mSingleTon2.getClass().getName(), mSingleTon2);
	}

	protected SingleTon2() {

	}

	public static SingleTon2 getInstance(String name) {
		if (name == null) {
			name = SingleTon2.class.getName();
		}
		/**
		 * 从JVM角度考虑，当new创建一个类的时候，这个类可以没有被加载。而使用newInstance（） 方法的售，必须保证：1.这个类已经加载
		 * 2.这个类已经连接了。完成上面两个步骤的真是 Class的静态方法forName()。这个静态方法调用了启动类加载器，即加载java
		 * API的 那个加载器。 最后用最简单的描述来区分new关键字和newInstance()方法的区别： newInstance:
		 * 弱类型。低效率。只能调用无参构造。 new: 强类型。相对高效。能调用任何public构造。
		 */
		if (map == null) {
			try {
				map.put(name, (SingleTon2) Class.forName(name).newInstance());
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		return map.get(name);
	}

	// 一个示意性的方法
	public String about() {
		return "I am good boy!";
	}

	public static void main(String[] args) {
		SingleTon2 mSingleTon2 = SingleTon2.getInstance(null);
		System.err.println(mSingleTon2.about());
	}
}

<pre name="code" class="java"> //它的子类SingleTon2Child需要弗雷的帮助才能实现。
public class SingleTon2Child extends SingleTon2{
	public SingleTon2Child(){
		
	}
	public static SingleTon2Child getInstance(){
		return (SingleTon2Child)SingleTon2.getInstance(SingleTon2Child.class.getName());
	}
}