`
zhouyrt
  • 浏览: 1158728 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

单例/单体模式(Singleton)

设计模式Java多线程JavaScript浏览器 
阅读更多

首先，单例模式是作为对象的创建模式，此外还包括工厂模式。单例模式的三个特点：
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单例模式实现事件管理模块的各个版本练习。

 

 

分享到：
| Javascript中大括号“{}”的多义性
评论
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;
}
}
唉，看不懂
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    javascript 单例/单体模式(Singleton)

    ### JavaScript 单例/单体模式 (Singleton) #### 概述 单例模式是一种常用的对象创建型设计模式，主要用于确保某个类只有一个实例，并且提供一个全局访问点来获取该实例。这种模式通常与工厂模式一起被提及，它们...

    javascript 设计模式之单体模式 面向对象学习基础

    JavaScript中的单体模式是一种设计模式，它用于确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一实例。这种模式在JavaScript中尤其重要，因为JavaScript是全局作用域的语言，容易导致变量冲突。单体模式...

    006Singleton.rar

    单体模式（Singleton）是设计模式中的一种结构型模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下都非常有用，例如管理共享资源、配置对象或者作为通信中心等。在C++编程中...

    C++ 单例模式的详解及实例

    单例模式是设计模式中的一种，它的核心思想是限制类的实例化，确保一个类只有一个实例，并提供一个全局访问点。在C++中，单例模式通常用于创建那些需要在整个应用程序生命周期内只被创建一次的对象，例如日志系统、...

    Delphi单体模式

    根据提供的标题、描述、标签及部分内容，我们可以详细探讨Delphi中的单例（Singleton）设计模式。单例模式是一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。 ### Delphi...

    Python单体模式的几种常见实现方法详解

    在软件工程设计模式中，单体模式（Singleton Pattern）是一种常用的创建型设计模式，主要用于确保一个类只有一个实例，并提供一个全局访问点来访问该实例。单体模式在Python等动态语言中有着多种实现方式。本文将...

    JavaScript中实现单体模式分享

    单体模式（Singleton Pattern）是一种设计模式，旨在确保一个类只有一个实例，并提供一个全局访问点。在JavaScript中，由于语言的特性和动态性，实现单体模式的方式与传统的面向对象语言（如Java、C++）有所不同。在...

    软件设计模式与体系结构ppt课件整理(考试必备)

    1. 创建型模式：如单例模式（Singleton）、工厂方法模式（Factory Method）和建造者模式（Builder），它们关注对象的创建过程，使得代码更加灵活和易于管理。 2. 结构型模式：包括适配器模式（Adapter）、装饰器...

    软件体系结构

    其中，“单体模式”可能指的是单例模式（Singleton Pattern），用于确保一个类只有一个实例，并提供一个全局访问点。而“行为模式”则涵盖了像策略模式（Strategy Pattern）、命令模式（Command Pattern）等一系列...

    javascript study

    1. **单体模式（Singleton）**：确保一个类只有一个实例，并提供一个全局访问点。在JavaScript中，通常通过闭包来实现单例。 2. **工厂模式**：用于创建对象，隐藏了对象创建的细节，使得对象的创建过程解耦于使用...

    ACE编程概述及部分函数介绍_中文

    - **实现类**：`ACE_Singleton<T>`，提供了单例模式的实现。 ##### 17. **库函数** - **功能**：提供了一系列实用的函数，如字符串操作、文件操作等。 - **示例**：`ACE_OS::strdup`用于复制字符串。 ##### 18....

Magicbox
Global site tag (gtag.js) - Google Analytics