单例/单体模式(Singleton)

首先，单例模式是作为对象的创建模式，此外还包括工厂模式。单例模式的三个特点：
1，该类只有一个实例
2，该类自行创建该实例(在该类内部创建自身的实例对象)
3，向整个系统公开这个实例接口

java中大概是这个样子:

 

class Singleton {
	
	//私有，静态的类自身实例
	private static Singleton instance = new Singleton();
	
	//私有的构造子(构造器,构造函数,构造方法)
	private Singleton(){}
	
	//公开，静态的工厂方法
	public static Singleton getInstance() {
		return instance;
	}
}

 

使用时：
Singleton obj = Singleton.getInstance();

 

这个单例类在自身被加载时instance会被实例化，即便加载器是静态的。
因此，对于资源密集，配置开销较大的单体更合理的做法是将实例化(new)推迟到使用它的时候。
即惰性加载(Lazy loading)，它常用于那些必须加载大量数据的单体。修改下：

 

class LazySingleton {
	//初始为null，暂不实例化
	private static LazySingleton instance = null;
	
	//私有的构造子(构造器,构造函数,构造方法)
	private LazySingleton(){}
	
	//公开，静态的工厂方法，需要使用时才去创建该单体
	public static LazySingleton getInstance() {
		if( instance == null ) {
			instance = new LazySingleton();
		}
		return instance;
	}	
}

 

使用方式同上。

 

单例模式是javascript最基本，最有用的模式之一。它提供了一种将代码组织为一个逻辑单元的手段，这个逻辑单元中的代码通过单一的变量进行访问。
单体在javascipt中有许多用处，可以用来划分命名空间，以减少全局变量的泛滥。还可以用在分支技术中用来处理各浏览器的差异。
javascript中单例模式的实现方式有多种，每一种都有自身的优点或缺点：

 

1，对象直接量实现最基本，最简单的单体

 

var Singleton = {
	attr1 : 1,
	attr2 : 'hello',
	method1 : function(){alert(this.attr2);},
	method2 : function(arg){}
}

 

这种方式中，对象所有成员都通过Singleton加点号访问。所有成员是公开的，没有私有的。
在执行到变量Singleton时，会加载(实例化)自身，即非惰性加载。
此外method1用this访问单体的其它成员会存在一些风险，因为method1的上下文不是总是指向Singleton对象。
比如当把method1作为事件监听器时，this可能指向的是dom元素，这时可能会提示undefined。

 

 

2，闭包实现私有成员的单体

 

var Singleton = function(){
	var attr = 1, fn = function(){};
	return {
		method : function(){ fn(); },
		getAttr : function(){ return attr; }		
	};	
}();

 

这种方式中var定义私有的成员属性attr，方法fn，然后返回一个公开的接口method和getAttr。
今后修改实现时，接口方法method和getAttr不变，只需修改私有的attr和fn的具体实现。
使用如下：

 

Singleton.method();
Singleton.getAttr();

 

3，闭包实现私有成员的惰性实例化单体

 

var LazySingleton = function(){
	var attr = 1, fn = function(){};
	var obj = {
		method : function(){ fn(); },
		getAttr : function(){ return attr; }
	};
	function init(){
		return obj;
	}
	return {getInstace: init};
}();

 

适用场合上面已经提到：对于那些必须加载大量数据的单体直到需要使用它的时候才实例化。使用方式是这样的：

LazySingleton.getInstance().method();
LazySingleton.getInstance().getAttr();

 

 

 

附件：js单例模式实现事件管理模块的各个版本练习。

 

 

评论

22 楼 lihengzkj 2011-01-26  

其实单例模式有3中实现的，楼主实现了一个。后面的有同行实现了同步块，我就补充哈，其实还有个同步方法的。
public class Man{
  private Man(){}
private static Man man = null;
        //使用了同步方法
public static synchronized Man getMan(){
if(man == null){
man = new Man();
}
return man;
}
}

21 楼 hongyang321 2011-01-25  

对的，没考虑线程安全

20 楼 kun166 2011-01-25  

双锁机制来源于C++，但是在java中貌似不可以，大家可以参考下《java与模式》这本书。

19 楼 shansun123 2010-07-28  

浪客剑心 写道

解决多线程的问题有3种方案：
1，直接用同步getInstance()方法，该方法不考虑性能的开销
2，早实例(early instantiate)，即相对于懒实例。
3.双锁机制。前提：至少jdk1.5

正解。。 LZ总结的也很不错。。

18 楼 xiaolixv 2010-07-27  

不错！！ 受教了 T H A N K Y O U

17 楼 accphc 2010-07-27  

一个Event那么多的版本！好强大

16 楼 huangyuanmu 2010-06-25  

kissroom112 写道

huangyuanmu 写道

yunj 写道

Lazy loading singleton

public class Singleton {

  private static final class A {
    public static final Singleton s = new Singleton();
  }
  
  private Singleton() {
    
  }
  
  public static Singleton getInstance() {
    return A.s;
  }
}

个人认为，这是java中，实现singleton模式的一种最完美的方式。

为什么为最完美呢？

1.实现了单例模式。
2.实现了lazy loading。
3.几乎没有缺陷。
4.适合任何java版本和虚拟机。

15 楼 kissroom112 2010-06-25  

huangyuanmu 写道

yunj 写道

Lazy loading singleton

public class Singleton {

  private static final class A {
    public static final Singleton s = new Singleton();
  }
  
  private Singleton() {
    
  }
  
  public static Singleton getInstance() {
    return A.s;
  }
}

个人认为，这是java中，实现singleton模式的一种最完美的方式。

为什么为最完美呢？

14 楼 huangyuanmu 2010-06-25  

yunj 写道

Lazy loading singleton

public class Singleton {

  private static final class A {
    public static final Singleton s = new Singleton();
  }
  
  private Singleton() {
    
  }
  
  public static Singleton getInstance() {
    return A.s;
  }
}

个人认为，这是java中，实现singleton模式的一种最完美的方式。

13 楼 cin_ie 2010-06-25  

很好，很好。

12 楼 zhouyrt 2010-06-25  

jinkingmanager 写道

class LazySingleton {
	//初始为null，暂不实例化
	private static Singleton instance = null;
	
	//私有的构造子(构造器,构造函数,构造方法)
	private Singleton(){}
	
	//公开，静态的工厂方法，需要使用时才去创建该单体
	public static Singleton getInstance() {
		if( instance == null ) {
			instance = new LazySingleton();
		}
		return instance;
	}	
}

Singleton哪里来的？
应该是LazySingleton吧
替换不完全？

谢谢你的提醒！

11 楼 jinkingmanager 2010-06-25  

class LazySingleton {
	//初始为null，暂不实例化
	private static Singleton instance = null;
	
	//私有的构造子(构造器,构造函数,构造方法)
	private Singleton(){}
	
	//公开，静态的工厂方法，需要使用时才去创建该单体
	public static Singleton getInstance() {
		if( instance == null ) {
			instance = new LazySingleton();
		}
		return instance;
	}	
}

Singleton哪里来的？
应该是LazySingleton吧
替换不完全？

10 楼 toko_yuki 2010-06-23  

额...居然没有发现双锁...

不过总结得不错，JS部分受教了。

9 楼 udvs 2010-06-23  

我记得这样的方式，如果使用反射，访问控制会无效

8 楼 yunj 2010-05-23  

Lazy loading singleton 一般实现采用：

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

还有一种最高效的实现,由java设计者写出来的

public class Singleton {

  private static final class A {
    public static final Singleton s = new Singleton();
  }
  
  private Singleton() {
    
  }
  
  public static Singleton getInstance() {
    return A.s;
  }
}

7 楼 liulei0616 2010-05-22  

真的不错，现在做项目自己编写的这方面的代码很少，好好学习学习

6 楼 浪客剑心 2010-05-19  

解决多线程的问题有3种方案：
1，直接用同步getInstance()方法，该方法不考虑性能的开销
2，早实例(early instantiate)，即相对于懒实例。
3.双锁机制。前提：至少jdk1.5

5 楼 12345678 2010-05-18  

多线程情况下使用双锁机制，就解决了。

4 楼 wensong 2010-05-18  

class LazySingleton {
	//初始为null，暂不实例化
	private static Singleton instance = null;
	
	//私有的构造子(构造器,构造函数,构造方法)
	private Singleton(){}
	
	//公开，静态的工厂方法，需要使用时才去创建该单体
	public static Singleton getInstance() {
		if( instance == null ) {
			instance = new LazySingleton();
		}
		return instance;
	}	
}

理论上这里可能getInstance()获得的对象是非线程安全的

3 楼 wpfwupengfeiwpf 2010-05-18  

class LazySingleton {
//初始为null，暂不实例化
private static Singleton instance = null;

//私有的构造子(构造器,构造函数,构造方法)
private Singleton(){}

//公开，静态的工厂方法，需要使用时才去创建该单体
public static Singleton getInstance() {
if( instance == null ) {
instance = new LazySingleton();
}
return instance;
}
}
唉，看不懂