设计模式(Design pattern):
是一套被反复使用, 多数人知晓的, 经过分类遍目的,代码设计经验的总结.
目的:
使用设计模式是为了可重用代码, 让代码更容易被他人理解, 保证代码的可靠性
单例模式(Singleton):
保证整个应用中某个实例有且只有一个
有些对象我们只需要一个: 配置文件, 工具类, 线程池, 缓存, 日志对象等.
如果创造出多个实例就会导致训多问题: 比如占用过多资源,不一致的结果等
单例模式三要素:
1. 静态的私有的本类型的变量
2. 构造方法私有化
3. 提供一个公共的静态的入口点方法
//第一种: 饿汉式
public class SingletonParrent01 {
public static void main(String[] args){
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
class Singleton{
private Singleton(){}
private static Singleton instance = new Singleton();;
public static Singleton getInstance(){
return instance;
}
}
类加载阶段创建对象, 并且只创建一次
不好处, 无论这个类是否被使用,都会创建. 所以很多创建过程是无用的.
//第二种: 懒汉式lazy loaded
public class SingletonParrent2 {
public static void main(String[] args){
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
System.out.println(s1);
System.out.println(s2);
}
}
class Singleton{
private Singleton(){}
private static Singleton instance;
public static Singleton getInstance(){
if(instance == null)
instance = new Singleton();
return instance;
}
}
上面的代码很清楚,也很简单。然而就像那句名言:“80%的错误都是由20%代码优化引起的”。单线程下,这段代码没有什么问题,可是如果是多线程,麻烦就来了。
我们来分析一下:
线程A希望使用Singleton,调用getInstance()方法。因为是第一次调用,A就发现instance是null的,于是它开始创建实例,就在这个时候,CPU发生时间片切换,线程B开始执行,它要使用Singleton,调用getInstance()方法,同样检测到instance是null——注意,这是在A检测完之后切换的,也就是说A并没有来得及创建对象——因此B开始创建。B创建完成后,切换到A继续执行,因为它已经检测完了,所以A不会再检测一遍,它会直接创建对象。这样,线程A和B各自拥有一个Singleton的对象——单例失败!
所以懒汉式是线程不安全的.
所以,我们用加锁来试一下.
public class Singleton {
private static Singleton instance = null;
public synchronized static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
private Singleton() {}
}
这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了
但是不管是否为Null, 只要调用getInstance()方法, 都会进入synchronized同步代码块, 速度会很慢. 性能很低.让我们来分析一下,究竟是整个方法都必须加锁,还是仅仅其中某一句加锁就足够了?我们为什么要加锁呢?分析一下出现lazy loaded的那种情形的原因。原因就是检测null的操作和创建对象的操作分离了。如果这两个操作能够原子地进行,那么单例就已经保证了。于是,我们开始修改代码:
//double-checked locking
public class Singleton {
private static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
private Singleton() {
}
}
首先判断instance是不是为null,如果为null,加锁初始化;如果不为null,直接返回instance。
从源头检查:
下面我们开始说编译原理。所谓编译,就是把源代码“翻译”成目标代码——大多数是指机器代码——的过程。针对Java,它的目标代码不是本地机器代码,而是虚拟机代码。编译原理里面有一个很重要的内容是编译器优化。所谓编译器优化是指,在不改变原来语义的情况下,通过调整语句顺序,来让程序运行的更快。这个过程成为reorder。要知道,JVM只是一个标准,并不是实现。JVM中并没有规定有关编译器优化的内容,也就是说,JVM实现可以自由的进行编译器优化。
下面来想一下,创建一个变量需要哪些步骤呢?
一个是申请一块内存,调用构造方法进行初始化操作,另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢?JVM规范并没有规定。那么就存在这么一种情况,JVM是先开辟出一块内存,然后把指针指向这块内存,最后调用构造方法进行初始化。
下面我们来考虑这么一种情况:线程A开始创建SingletonClass的实例,此时线程B调用了getInstance()方法,首先判断instance是否为null。按照我们上面所说的内存模型,A已经把instance指向了那块内存,只是还没有调用构造方法,因此B检测到instance不为null,于是直接把instance返回了——问题出现了,尽管instance不为null,但它并没有构造完成,就像一套房子已经给了你钥匙,但你并不能住进去,因为里面还没有收拾。此时,如果B在A将instance构造完成之前就是用了这个实例,程序就会出现错误了!
解决方案:
说了这么多,难道单例没有办法在Java中实现吗?其实不然!在JDK 5之后,Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前,volatile是个关键字,但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整,读变量不能和之后的读写代码调整!因此,只要我们简单的把instance加上volatile关键字就可以了。
/*
volatile关键字
*/
public class Singleton {
private volatile static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
private Singleton() {
}
}
而,这只是JDK1.5之后的Java的解决方案,那之前版本呢?其实,还有另外的一种解决方案,并不会受到Java版本的影响:
/*
静态内部类方式
*/
public class Singleton {
private static class SingletonInstance {
private static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonInstance.instance;
}
private Singleton() {
}
}
在这一版本的单例模式实现代码中,我们使用了Java的静态内部类。这一技术是被JVM明确说明了的,因此不存在任何二义性。在这段代码中,因为SingletonClass没有static的属性,因此并不会被初始化。直到调用getInstance()的时候,会首先加载SingletonClassInstance类,这个类有一个static的SingletonClass实例,因此需要调用SingletonClass的构造方法,然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是static的,因此并不会构造多次。
由于SingletonClassInstance是私有静态内部类,所以不会被其他类知道,同样,static语义也要求不会有多个实例存在。并且,JSL规范定义,类的构造必须是原子性的,非并发的,因此不需要加同步块。同样,由于这个构造是并发的,所以getInstance()也并不需要加同步。
至此,我们完整的了解了单例模式在Java语言中的时候,提出了两种解决方案。个人偏向于第二种,并且Effiective Java也推荐的这种方式。
几个例子:
/*
* 单例模式管理用户
* */
public class UserManager {
private static UserManager instance = new UserManager();
private UserManager(){}
public static UserManager getInstance(){
return instance;
}
}
/*
封装数据库操作
*/
public final class DbHelper {
private static DbHelper instance = null;
public static DbHelper getInstance() {
if (instance == null) {
// 给类加锁 防止线程并发
synchronized (DbHelper.class) {
if (instance == null) {
instance = new DbHelper();
}
}
}
return instance;
}
private DbHelper() {}
// 获得连接getConnection()
// 关闭连接close()
//...
}