本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/wanghao72214/archive/2009/04/02/4042607.aspx
1 單例模式的日常應用
我們在瀏覽BBS、SNS網站的時候，常常會看到“當前在線人數”這樣的一項內容。對於這樣的一項功能，我們通常的做法是把當前的在線人數存放到一個內存、文件或者數據庫中，每次用戶登錄的時候，就會馬上從內存、文件或者數據庫中取出，在其基礎上加1後，作爲當前的在線人數進行顯示，然後再把它保存回內存、文件或者數據庫裏，這樣後續登錄的用戶看到的就是更新後的當前在線人數；同樣的道理，當用戶退出後，當前在線人數進行減1的工作。所以，對於這樣的一個需求，我們按照面向對象的設計思想，可以把它抽象爲“在線計數器”這樣一個對象，具體實現如下：
Java代碼：
//在線人數計數器
class OnlineCounter {
//在線人數
private int onlineCount = 0;
//構造函數
public OnlineCounter(){
//從文件或者數據庫讀取數據,假如讀出來的數據是100
this.onlineCount = 100;
}
//在用戶登錄後，在線人數加1
public void incCount(){
this.onlineCount++;
}
//在用戶退出後，在線人數減1
public void decCount(){
this.onlineCount--;
}
//保存在線人數
public void saveCount(){
}
//獲取在線人數
public int getCount(){
return onlineCount;
}
//測試函數
public static void main(String[] args) {
try{
OnlineCounter onlineCounter = new OnlineCounter();
System.out.println("在線人數：" +onlineCounter.getCount());
onlineCounter.incCount();
System.out.println("在線人數：" + onlineCounter.getCount());
onlineCounter.decCount();
System.out.println("在線人數：" + onlineCounter.getCount());
}catch(Exception err){
}
}
}
.Net代碼：
//在線人數計數器
class OnlineCounter{
//在線人數
private int onlineCount = 0;
//構造函數
public OnlineCounter(){
//從文件或者數據庫讀取數據,假如讀出來的數據是100
this.onlineCount = 100;
}
//在用戶登錄後，在線人數加1
public void incCount(){
this.onlineCount++;
}
//在用戶退出後，在線人數減1
public void decCount(){
this.onlineCount--;
}
//保存在線人數
public void saveCount(){
return onlineCount;
}
//獲取在線人數
public int getCount(){
return onlineCount;
}
//測試函數
public static void Main(string[] args) {
OnlineCounter onlineCounter = new OnlineCounter();
Console.WriteLine("在線人數：" + onlineCounter.getCount());
onlineCounter.incCount();
Console.WriteLine("在線人數：" + onlineCounter.getCount());
onlineCounter.decCount();
Console.WriteLine("在線人數：" + onlineCounter.getCount());
}
}
Php代碼：
<?php
//在線人數計數器
class OnlineCounter {
//在線人數
private $onlineCount = 0;
//構造函數
public function __construct(){
//從文件或者數據庫讀取數據,假如讀出來的數據是100
$this->onlineCount = 100;
}
//在用戶登錄後，在線人數加1
public function incCount(){
$this->onlineCount++;
}
//在用戶退出後，在線人數減1
public function decCount(){
$this->onlineCount--;
}
//保存在線人數
public function saveCount(){
}
//獲取在線人數
public function getCount(){
return $this->onlineCount;
}
//測試函數
public static function execute() {
$onlineCounter = new OnlineCounter();
echo "在線人數：" . $onlineCounter->getCount();
$onlineCounter->incCount();
echo "在線人數：" . $onlineCounter->getCount();
$onlineCounter->decCount();
echo "在線人數：" . $onlineCounter->getCount();
}
}
OnlineCounter::execute();
?>
運行結果如下：
在線人數：100
在線人數：101
在線人數：100
網站代碼中凡是用到計數器的地方，只要new一個計數器對象，然後就可以獲取、保存、增加或者減少在線人數的數量。不過，我們的代碼實際的使用效果並不好。假如有多個用戶同時登錄,那麼在這個時刻，通過計數器取到的在線人數是相同的，於是他們使用各自的計數器加1後存入文件或者數據庫。這樣操作後續登陸的用戶得到的在線人數，與實際的在線人數並不一致。所以，把這個計數器設計爲一個全局對象，所有人都共用同一份數據，就可以避免類似的問題，這就是我們所說的單例模式的其中的一種應用。
2 什麼是單例模式
單例模式能夠保證一個類僅有唯一的實例，並提供一個全局訪問點。
我們是不是可以通過一個全局變量來實現單例模式的要求呢？我們只要仔細地想想看，全局變量確實可以提供一個全局訪問點，但是它不能防止別人實例化多個對象。通過外部程序來控制的對象的產生的個數，勢必會系統的增加管理成本，增大模塊之間的耦合度。所以，最好的解決辦法就是讓類自己負責保存它的唯一實例，並且讓這個類保證不會產生第二個實例，同時提供一個讓外部對象訪問該實例的方法。自己的事情自己辦，而不是由別人代辦，這非常符合面向對象的封裝原則。
按照以上的思路，我們可以這樣來設計單例類：
Java代碼:
class Singleton {
// 私有的靜態對象
private static Singleton instance = null;
//私有的構造方法
private Singleton (){
}
// 公開的靜態工廠方法,返回此類的唯一實例
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
.Net代碼：
class Singleton{
// 私有的靜態對象
private static Singleton instance = null;
//私有的構造方法
private Singleton(){
}
//公開的靜態工廠方法,返回此類的唯一實例
public static Singleton getInstance(){
if (instance == null){
instance = new Singleton();
}
return instance;
}
}
Php代碼：
<?php
class Singleton {
// 私有的靜態對象
private static $instance = null;
//私有的構造方法
private function __construct(){
}
// 公開的靜態工廠方法,返回此類的唯一實例
public static function getInstance(){
if(self::$instance == null){
self::$instance = new Singleton();
}
return self::$instance;
}
}
?>
Singleton類含有一個instance的私有靜態變量,用來保存該類唯一的實例對象，它對於外部對象是不可見的，只能通過getInstance方法才能獲得。
Singleton類的構造器是private私有的，外部對象無法通過它的構造器生成實例，也就是說外部程序試圖通過new操作符來創建實例是行不通的，因此，getInstance方法成爲獲得Singleton類實例的唯一途徑。
getInstance方法的設計非常簡單，它首先檢測instance變量是否已經初始化，如果沒有被初始化，就創建一個實例保存到instance變量，最後返回這個實例；如果這個實例已經被初始化，那麼就直接返回這個實例。
getInstance方法的設計非常簡單，它首先檢測instance變量是否已經初始化，如果沒有被初始化，就創建一個實例保存到instance變量，最後返回這個實例；如果這個實例已經被初始化，那麼就直接返回這個實例。
單例模式的類圖
單例模式主要有3個特點，：
1、單例類確保自己只有一個實例。
2、單例類必須自己創建自己的實例。
3、單例類必須爲其他對象提供唯一的實例。
3 安全的單例模式：雙重檢查鎖定機制
我們雖然實現了單例模式，但是目前的解決辦法並不安全，依然存在着一定的缺陷：
class Singleton {
private static Singleton instance = null;
private Singleton (){
}
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
這段代碼意圖通過檢查if (instance == null)這個條件，來保證只創建一個Singleton實例。事實上，它運行在單線程環境中，得到的結果是正確的，沒有問題，但是運行在多線程的環境中，它就會出現錯誤，可能有多個Singleton實例被創建出來。
我們分析一下，在多線程環境中，可能會出現這樣的情形：線程A 和線程B幾乎同時到達if (instance == null)語句，假設線程A 比線程B 早一點點，那麼：
（1）A 會首先進入if (instance == null)塊的內部，並開始執行new Singleton () 語句。此時，instance變量仍然是null，直到線程A 的new Singleton () 語句返回，並給instance變量賦值爲止。
（2） 但是，此時的線程B 並不會在if (instance == null)語句的外面等待，因爲此時(instance == null)是成立的，它會馬上進入if (instance == null)語句塊的內部。這樣，線程B 會不可避免地執行instance=new Singleton()語句，從而創建出第二個實例來。
（3）線程A 的instance=new Singleton()語句執行完畢後，instance變量得到了真實的對象引用，(instance == null)不再爲真。所以，後來的線程就不會再進入if (instance == null) 語句塊的內部了。
（4）線程B 的instance=new Singleton()語句也執行完畢後，instance變量的值被覆蓋。但是第一個instance對象被線程A 引用的事實已經無法改變了。這時候的線程A和B各自擁有一個獨立的Singleton對象。
爲了實現線程安全，我們對代碼進行了一定的改造：
Java代碼：
class Singleton{
private static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance(){
//位置1，第1次檢查instance
if (instance == null)
{
//位置2，某一時刻可能有n個線程到達
synchronized (this)
{
//位置3，任何時間只能有1個線程到達
if (instance == null) //位置4，第2次檢查instance
{
instance = new Singleton();
}
}
}
return instance;
}
}
.Net代碼：
class Singleton {
private static Singleton instance = null;
private static readonly object syncObj = new object();
private Singleton (){
}
public static Singleton getInstance(){
//位置1，第1次檢查instance
if( instance == null ){
//位置2，某一時刻可能有n個線程到達
lock(syncObj)
{
//位置3，任何時間只能有1個線程到達
if (instance == null) //位置4，第2次檢查instance
{
instance = new Singleton();
}
}
}
return instance;
}
}
我們通過引入了Java的synchronized或者.Net的lock同步化限制，各個線程到達臨界區時，就會按照線性方式逐個執行。
我們再來分析一下：
（1）在多線程環境中，線程A 和B同時或幾乎同時到達位置1。
（2）假設線程A 會首先到達位置2，並進入synchronized(this) 到達位置3。這時，由於synchronized(this) 的同步化限制，線程B 無法到達位置3，而只能在位置2 等候。
（3）線程A 執行instance = new Singleton()語句，instance變量得到賦值，此時，線程B 還只能繼續在位置2 等候。
（4）線程A 退出synchronized(this) 塊，並返回instance對象。
（5）線程B 進入synchronized(this)塊，到達位置3，進而到達位置4。由於instance變量已經不是null 了，因此線程B 退出synchronized(this)，並返回instance，這時候的instance只有一個。
我們通過兩次檢查instance是否被實例化來解決線程安全問題，這種處理方式稱爲雙重檢查鎖定機制（Double-checked locking）。還有另外一種解決線程安全的方法，就是把getInstance方法整體作爲同步區，比如聲明爲public static synchronized Singleton getInstance()，這種方式由於鎖定的區域過大，特殊情況下會造成系統性能的下降，成爲系統的性能瓶頸。
雙重檢查鎖定機制不僅解決了線程安全問題，而且把性能也處理得很不錯，看起來非常完美。不幸的是我們應該注意不要在java中使用雙重檢查鎖定機制，由於Java編譯器和 JIT 的優化的原因，系統無法保證我們期望的執行次序。雖然Java語法中的volatile修飾符可以強制屏蔽編譯器和 JIT 的優化工作，但它是一種非常脆弱的同步機制，比較難以控制，所以建議儘量減少使用。我們後面還提供了其它的一種實現方式。
4 單例模式的實現方式：懶漢單例類和餓漢單例類
單例模式的實現有多種方法，常見的就有懶漢式單例類和餓漢式單例類。我們前面介紹的實現方法就屬於懶漢式單例類。
l 懶漢式單例類
對於懶漢模式，我們可以這樣理解：該單例類非常懶，只有在自身需要的時候纔會行動，從來不知道及早做好準備。它在需要對象的時候，才判斷是否已有對象，如果沒有就立即創建一個對象，然後返回，如果已有對象就不再創建，立即返回。
懶漢模式只在外部對象第一次請求實例的時候纔去創建。
l 餓漢式單例
對於餓漢模式，我們可以這樣理解：該單例類非常餓，迫切需要吃東西，所以它在類加載的時候就立即創建對象。
Java代碼：
final class Singleton {
//私有的唯一實例成員,在類加載的時候就創建好了單例對象
private static final Singleton instance = new Singleton();
//私有的構造方法,避免外部創建類實例
private Singleton() {
}
//靜態工廠方法,返回此類的唯一實例
public static Singleton getInstance() {
return instance;
}
}
.Net代碼：
sealed class Singleton {
//私有的唯一實例成員,在類加載的時候就創建好了單例對象
private static readonly Singleton instance = new Singleton();
//私有的構造方法,避免外部創建類實例
private Singleton() {
}
//靜態工廠方法,返回此類的唯一實例
public static Singleton getInstance() {
return instance;
}
}
使用Java中的final關鍵字和.Net中sealed關鍵字去修飾class，目的是阻止派生子類，而派生子類可能會導致實例不唯一。使用Java中的final關鍵字和.Net中readonly關鍵字去修飾變量，就意味着只能在類初始化時或者在構造器中分配該變量。
我們對比一下懶漢模式和餓漢模式的優缺點：
這兩種模式對於初始化較快，佔用資源少的輕量級對象來說，沒有多大的性能差異，選擇懶漢式還是餓漢式都沒有問題。但是對於初始化慢，佔用資源多的重量級對象來說，就會有比較明顯的差別了。所以，對重量級對象應用餓漢模式，類加載時速度慢，但運行時速度快；懶漢模式則與之相反，類加載時速度快，但運行時第一次獲得對象的速度慢。
這兩種模式對於初始化較快，佔用資源少的對象來說，沒有多大的性能差異，但是對於初始化慢，佔用資源多的對象來說就會有比較明顯的差別了。所以，對重量級對象應用餓漢模式，在類加載時需要較長時間，但運行時會有明顯的時間效率的提升。對重量級對象應用懶漢模式，在類加載時很快，但至少第一次獲得對象時需要等待很長時間。
從用戶體驗的角度來說，我們應該首選餓漢模式。我們願意等待某個程序花較長的時間初始化，卻不喜歡在程序運行時等待太久，給人一種反應遲鈍的感覺，所以對於有重量級對象參與的單例模式，我們推薦使用餓漢模式。
而對於初始化較快的輕量級對象來說，選用哪種方法都可以。如果一個應用中使用了大量單例模式，我們就應該權衡兩種方法了。輕量級對象的單例採用懶漢模式，減輕加載時的負擔，縮短加載時間，提高加載效率；同時由於是輕量級對象，把這些對象的創建放在使用時進行，實際就是把創建單例對象所消耗的時間分攤到整個應用中去了，對於整個應用的運行效率沒有太大影響。
5 什麼情況下使用單例模式
單例模式也是一種比較常見的設計模式，它到底能帶給我們什麼好處呢？其實無非是三個方面的作用：
第一、控制資源的使用，通過線程同步來控制資源的併發訪問；
第二、控制實例產生的數量，達到節約資源的目的。
第三、作爲通信媒介使用，也就是數據共享，它可以在不建立直接關聯的條件下，讓多個不相關的兩個線程或者進程之間實現通信。
比如，數據庫連接池的設計一般採用單例模式，數據庫連接是一種數據庫資源。軟件系統中使用數據庫連接池，主要是節省打開或者關閉數據庫連接所引起的效率損耗，這種效率上的損耗還是非常昂貴的。當然，使用數據庫連接池還有很多其它的好處，可以屏蔽不同數據數據庫之間的差異，實現系統對數據庫的低度耦合，也可以被多個系統同時使用，具有高可複用性，還能方便對數據庫連接的管理等等。數據庫連接池屬於重量級資源，一個應用中只需要保留一份即可，既節省了資源又方便管理。所以數據庫連接池採用單例模式進行設計會是一個非常好的選擇。
在我們日常使用的在Windows中也有不少單例模式設計的組件，象常用的文件管理器。由於Windows操作系統是一個典型的多進程多線程系統，那麼在創建或者刪除某個文件的時候，就不可避免地出現多個進程或線程同時操作一個文件的現象。採用單例模式設計的文件管理器就可以完美的解決這個問題，所有的文件操作都必須通過唯一的實例進行，這樣就不會產生混亂的現象。
再比如，每臺計算機可以有若干個打印機，如果每一個進程或者線程都獨立地使用打印機資源的話，那麼我們打印出來的結果就有可能既包含這個打印任務的一部分，又包含另外一個打印任務的一部分。所以，大多數的操作系統最終爲打印任務設計了一個單例模式的假脫機服務Printer Spooler，所有的打印任務都需要通過假脫機服務進行。
實際上，配置信息類、管理類、控制類、門面類、代理類通常被設計爲單例類。像Java的Struts、Spring框架，.Net的Spring.Net框架，以及Php的Zend框架都大量使用了單例模式。