**单例模式**，也叫**单子模式**，是一种常用的软件设计模式，属于创建型模式的一种。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

实现单例模式的思路是：一个类能返回对象一个引用（永远是同一个）和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

单例模式在多线程的应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁（虽然这样会降低效率）。

构建方式
----

通常单例模式在Java语言中，有两种构建方式：

* 懒汉方式。指全局的单例实例在第一次被使用时构建。
* 饿汉方式。指全局的单例实例在类装载时构建。

例子
--

### Java

在Java语言中，单例模式（饿汉模式）应用的例子如下述代码所示：

```
 public class Singleton {
 private static final Singleton INSTANCE = new Singleton();
 
 // Private constructor suppresses
 // default public constructor
 private Singleton() {};
 
 public static Singleton getInstance() {
 return INSTANCE;
 }
 }

```

在Java编程语言中，单例模式（懒汉模式）应用的例子如下述代码所示 （此种方法只能用在JDK5及以后版本（注意 INSTANCE 被声明为 volatile），之前的版本使用"双重检查锁"会发生非预期行为）：

```
 public class Singleton {
 private static volatile Singleton INSTANCE = null;
 
 // Private constructor suppresses 
 // default public constructor
 private Singleton() {};
 
 //Thread safe and performance promote 
 public static Singleton getInstance() {
 if(INSTANCE == null){
 synchronized(Singleton.class){
 // When more than two threads run into the first null check same time, 
 // to avoid instanced more than one time, it needs to be checked again.
 if(INSTANCE == null){ 
 INSTANCE = new Singleton();
 }
 } 
 }
 return INSTANCE;
 }
 }

```

### C++

在C++编程语言中，单例模式应用的例子如下述代码所示（这里仅仅提供一个示例；由于加入了锁，这代码是线程安全的）：

```
// ...

class lock
{
 public:
 lock();
 lock(lock const & l);
 ~lock();
 lock & operator =(lock const & l);
 void request();
 void release();
 // ...
};

lock::lock()
{
 // ...
}

// ...

lock::~lock()
{
 // ...
}

// ...

void lock::request()
{
 // ...
}

void lock::release()
{
 // ...
}

// ...

// assumes \_DATA\_TYPE\_ has a default constructor
template<typename \_DATA\_TYPE\_>
class singleton
{
 public:
 static \_DATA\_TYPE\_ \* request();
 static void release();

 private:
 singleton();
 singleton(singleton<\_DATA\_TYPE\_> const & s);
 ~singleton();
 singleton<\_DATA\_TYPE\_> & operator =(singleton<\_DATA\_TYPE\_> const & s);
 static \_DATA\_TYPE\_ \* pointer;
 static lock mutex;
 // ...
};

template<typename \_DATA\_TYPE\_>
\_DATA\_TYPE\_ \* singleton<\_DATA\_TYPE\_>::pointer = nullptr;

template<typename \_DATA\_TYPE\_>
lock singleton<\_DATA\_TYPE\_>::mutex;

template<typename \_DATA\_TYPE\_>
\_DATA\_TYPE\_ \* singleton<\_DATA\_TYPE\_>::request()
{
 if(singleton<\_DATA\_TYPE\_>::pointer == nullptr)
 {
 singleton<\_DATA\_TYPE\_>::mutex.request();

 if(singleton<\_DATA\_TYPE\_>::pointer == nullptr)
 {
 singleton<\_DATA\_TYPE\_>::pointer = new \_DATA\_TYPE\_;
 }

 singleton<\_DATA\_TYPE\_>::mutex.release();
 }

 return singleton<\_DATA\_TYPE\_>::pointer;
}

template<typename \_DATA\_TYPE\_>
void singleton<\_DATA\_TYPE\_>::release()
{
 if(singleton<\_DATA\_TYPE\_>::pointer != nullptr)
 {
 singleton<\_DATA\_TYPE\_>::mutex.request();

 if(singleton<\_DATA\_TYPE\_>::pointer != nullptr)
 {
 delete singleton<\_DATA\_TYPE\_>::pointer;
 
 singleton<\_DATA\_TYPE\_>::pointer = nullptr;
 }

 singleton<\_DATA\_TYPE\_>::mutex.release();
 }
}

template<typename \_DATA\_TYPE\_>
singleton<\_DATA\_TYPE\_>::singleton()
{
 // ...
}

// ...

int main()
{
 int \* s;

 s = singleton<int>::request();

 // ...

 singleton<int>::release();

 return 0;
}

```

### GO

GO语言中的单例模式:

```
var \_instance \*service
var once sync.Once
type service struct {
 Name string
}

func Service() \*service {
 once.Do(func() {
 \_instance = &service{}
 })
 return \_instance
}

func (this \*service) Startup() {
}

func (this \*service) Stop() {

}

func (this \*service) Restart() {

}

```

### Objective-C

OC语言中的单例模式:

```
@interface Control : NSObject
+(id)getShare;
@end

static Control \*mControl;
@implementation Control
+(id)getShare
{
 if (mControl == nil) {
 mControl = [[Control alloc] init];
 }
 return mControl;
}

-(id)init {
//你需要初始化的属性。。。
}
@end

```

### PHP

PHP语言中的单例模式:

```
<?php
class singleton
{
    private function \_\_construct()
    {
    }
    
    static public function instance()
    {
        static $obj = null;
        if($obj === null)
        {
            $obj = new self();
        }
        return $obj;
    }
}
?>

```

参考文献
----

1. ↑  David Bacon,Joshua Bloch etc..  [2012-08-17]. （原始内容存档于2012-03-01） （英语）.

外部链接
----

* A Q&A page （java.sun.com）
* Java单例对象同步问题探讨 （页面存档备份，存于）

参见
--

* 多例模式

  


|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
软件设计模式 |
| --- |
|  |
| 设计模式 | 

|  |  |
| --- | --- |
| 创建型 | 
* 抽象工厂
* 生成器
* 工厂方法
* 惰性初始
* 原型
* 单例

 |
|  |
| 结构型 | 
* 适配器
* 桥接
* Composite（英语：）
* 修饰
* 外观
* 享元
* 代理

 |
|  |
| 行为型 | 
* 责任链
* 命令
* Interpreter（英语：）
* 迭代器
* 中介者
* Memento（英语：）
* 观察者
* Specification（英语：）
* State（英语：）
* 策略
* 模板方法
* 访问者

 |

 |
|  |
| 并行模式 | 
* 主动对象（英语：）
* 阻止（英语：）
* Binding properties（英语：）
* 双重检查锁定模式
* 异步方法调用
* Future与promise
* Guarded suspension（英语：）
* Join（英语：）
* 锁
* Messaging（英语：）
* 监视器
* Proactor（英语：）
* 反应器
* 读写锁
* 调度
* 线程池
* 线程局部存储

 |
|  |
| 架构模式 | 
* ADR（英语：）
* 主动记录
* Broker（英语：）
* 主從式架構
* cbd
* DAO
* DDD
* Data transfer object（英语：）
* Front controller（英语：）
* Identity map（英语：）
* Interceptor（英语：）
* 控制反转
* MVC
* 微服務
* MVP
* 單體式應用程式
* 多层架构
* *n*-tier（英语：）
* Naked objects（英语：）
* P2P
* 发布/订阅
* REST
* SOA
* Specification（英语：）

 |
|  |
| 云分布式 | 
* 断路器
* CQRS（英语：）
* 补偿交易（英语：）
* 索引表
* 领导者选举（英语：）
* MapReduce
* 物化视图（英语：）
* 管道
* 过滤器（英语：）
* 发布/订阅
* 分片（英语：）
* 节流（英语：）

 |
|  |
| 其他模式 | 
* Blackboard（英语：）
* Business delegate（英语：）
* Composite entity（英语：）
* 委托
* 依赖注入
* Intercepting filter（英语：）
* 惰性載入
* Method chaining（英语：）
* 模拟对象
* 空对象
* 对象池
* Servant（英语：）
* Twin（英语：）
* Type tunnel（英语：）

 |
|  |
| 书籍 | 
* 设计模式：可复用面向对象软件的基础
* 企业集成模式（英语：）

 |
|  |
| 人物 | 
* 克里斯托佛·亚历山大
* 埃里希·伽瑪
* Ralph Johnson（英语：）
* John Vlissides（英语：）
* 葛來迪·布區
* 肯特·貝克
* 沃德·坎宁安
* 马丁·福勒
* Robert Martin（英语：）
* Jim Coplien（英语：）
* Douglas Schmidt（英语：）
* Linda Rising

 |
|  |
| 社区 | 
* The Hillside Group（英语：）
* The Portland Pattern Repository（英语：）

 |

 |