单例模式-Singleton

0.前言

在一年多前就开始学习设计模式了，主要看的是GoF的那本书《设计模式-可复用面向对象软件的基础》，很好的一本书。当时没打算开博客，所以把所有笔记都写到了OneNote上，现在想好好整理下，尽量都写到博客里面来，一方面希望对他人有帮助，一方面也是自己知识的一个积累和巩固的过程。

 

1.正文

在23个设计模式中，最简单应该就是单例(Singleton)模式了，个人感觉学习设计模式才能更好地理解各种源码的设计，提高代码的复用性以及提高自己的编程能力。

 

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

 

对一些类来说，只有一个实例是很重要的。比如说线程池、缓存、对话框、日志对象等。一个全局变量使得一个对象可以被访问到，但它不能防止你实例化多个对象。 那我们怎样才能保证只有一个实例呢 ?一个好的方法就是让类自身负责保存它的唯一实例。这个类可以保证没有其它实例可以被创建，并且它提供一个访问该实例的方法。这就是单例模式(Singleton)。

 

 

结构图

 

 

示例代码

 

package com.rdc.dp;

public class Singleton {
	private static Singleton instance = null;
	
	//构造方法类型是protected，意味着在同一包中的所有类和不同包的子类中都可以访问
	//这时可以改为private类型，这样就只有本类可以访问
	//private Singleton() {}
	protected Singleton() {}
	public static Singleton getIntance() {
		//延迟实例化
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}

}

 

定义一个私有的静态实例变量instance，创建这个实例的操作隐藏在本类中的一个类方法getInstance，而这个类方法保证了只有一个实例被创建。这个getInstance方法可以访问唯一的实例变量，并且可以保证这个变量在返回值之前用这个唯一实例初始化。这里还有一个无参的构造方法，其实你可以根据需要进行初始化操作。需要注意的是，这里的构造方法的类型是protected，意味着在同一包中的所有类和不同包的子类中都可以访问，这时可以改为private，这样就只有本类可以访问。

 

 

测试方法

 

package com.rdc;
import com.rdc.dp.Singleton;

public class Main {
	public static void main(String[] args) {
		//这里不能用new，不同包无法访问，同包的话构造方法需改为private
		Singleton s1 = Singleton.getIntance();
		Singleton s2 = Singleton.getIntance();
		//测试得到的两个实例是否相同
		if(s1 == s2){
			System.out.println("Objects are the same instance!!");
		} 
	}
}

 

 

测试得到的结果是：Objects are the same instance!!

成功了，我们做到了一个类只实例化一个。很简单是吧，确实，正常情况下这个类只能实例化一个，但如果是多线程情况下会怎么样呢？

 

试想一下，假如我们有两个线程，当线程1执行到 if(instance == null)，赋值语句instance = new Singleton() 还没发生之前，这时的instance是为null的，然后恰巧这时转到线程2去运行了，它刚好执行到if判断。在这种情况下就会有两个不同的实例被创建了。那该怎么解决呢？

解决办法

一是可以给方法加锁，即当执行到这个方法时，不管哪一个线程，每次运行到这个方法时，都要检查有没有其它正在用这个方法的线程，有的话要等这个方法执行完后再运行该线程，没有的话直接运行。注意：给方法同步的开销是比较大的，慎用。

 

修改上面的getInstance方法

 

//让方法同步
public synchronized static Singleton getIntance() {
	//延迟实例化
	if(instance == null) {
		instance = new Singleton();
	}
	return instance;
}

 

二是定义实例变量时就new出来，然后getIntance方法不要延迟加载。

 

package com.rdc.dp;

public class Singleton {
        //定义为static，然后在这里new，调用时只加载一次
	private static Singleton instance = new Singleton();
	
	protected Singleton() {}
	public static Singleton getIntance() {
                //不要延迟加载
		return instance;
	}
	
}

 

 

三是使用Double-Checked Locking，volatile是在JDK 1.5之后才有的，具体实现如下：

public class Singleton {
    private volatile static Singleton instance = null;

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

 

 

 

这样，单例模式的简单例子就差不多了。

 

评论

2 楼 crd1991 2012-04-01  

jilen 写道

这种同步开销，我认为还不如不使用延迟加载。
如果需要延迟，可用使用Double Checked Locking

嗯嗯，没错，同步开销比较大，谢谢指点。

1 楼 jilen 2012-03-31  

这种同步开销，我认为还不如不使用延迟加载。
如果需要延迟，可用使用Double Checked Locking