Java 是較典型的面向對象語言。如果說 C++ 是設計模式的發源地(GoF 的書使用 C++ 描述的)，那么 Java 將設計模式發揚光大。設計模式，很多人可能工作中沒有用到，因為大部分人停留在寫面條式的業務代碼，從頭擼到尾，沒有設計可言。但實際上，只要你用心思考，這樣的場景下也是很有可能用上設計模式的。特別是，當系統復雜時，設計模式的作用會很明顯。

雖然 Go 語言并非完全的面向對象語言，只提供了部分面向對象的特性，但一些設計模式還是可以使用的。這個系列嘗試講解在 Go 中使用設計模式，同時給出 Java 對應的版本，進行對比學習。另外，我們的設計模式不會局限在 GoF 的 23 中設計模式之中。

在開始設計模式之前，有必要提一下面向對象的 SOLID 5 大設計原則：

名稱縮寫含義The Single Responsibility Principle(單一職責)S對象應該具有單一的職責。這也是 Unix 的設計哲學The Open/Closed Principle(開/閉原則)O對擴展開發，對修改關閉The Liskov Substitution Principle(里氏替換)L對象應該可以在不破壞系統的情況下被子對象替換The Interface Segregation Principle(接口隔離)I不應強迫任何客戶端依賴其不使用的方法The Dependency Inversion Principle(依賴倒轉)D高級模塊不應依賴于低級實現

遵循這樣的設計原則，你的系統會更好維護。

除了 SOLID 5 大設計原則，一些書上可能還會提到下面的設計原則：

• 合成/聚合復用原則(Composite/Aggregate Reuse Principle)：盡量使用合成/聚合，而不要使用繼承。這也是 Go 語言設計遵循的，基于此，Go 中沒有繼承。
• 迪米特法則(LoD)，又叫 最少知識原則：一個對象應當對其他對象有盡可能少的了解;一個軟件實體應當與盡可能少的其他實體發生相互作用。

在你日常的工作中，可以運用以上原則審視你的設計，改進你的設計。

今天先看第一個設計模式。

1、單例模式簡介

面向對象中的單例模式是一個常見、簡單的模式。

英文名稱：Singleton Pattern，該模式規定一個類只允許有一個實例，而且自行實例化并向整個系統提供這個實例。因此單例模式的要點有：1)只有一個實例;2)必須自行創建;3)必須自行向整個系統提供這個實例。

單例模式主要避免一個全局使用的類頻繁地創建與銷毀。當你想控制實例的數量，或有時候不允許存在多實例時，單例模式就派上用場了。

先看 Java 中的單例模式。

通過該類圖我們可以看出，實現一個單例模式有如下要求：

• 私有、靜態的類實例變量;
• 構造函數私有化;
• 靜態工廠方法，返回此類的唯一實例;

根據實例化的時機，單例模式一般分成餓漢式和懶漢式。

• 餓漢式：在定義 instance 時直接實例化，private static Singleton instance = new Singleton();
• 懶漢式：在 getInstance 方法中進行實例化;

那兩者有什么區別或優缺點?餓漢式單例類在自己被加載時就將自己實例化。即便加載器是靜態的，餓漢式單例類被加載時仍會將自己實例化。單從資源利用率角度講，這個比懶漢式單例類稍差些。從速度和反應時間角度講，則比懶漢式單例類稍好些。然而，懶漢式單例類在實例化時，必須處理好在多個線程同時首次引用此類時的訪問限制問題，特別是當單例類作為資源控制器在實例化時必須涉及資源初始化，而資源初始化很有可能耗費時間。這意味著出現多線程同時首次引用此類的幾率變得較大。

2、單例模式的 Java 實現

結合上面的講解，以一個計數器為例，我們看看 Java 中餓漢式的實現：

public class Singleton { 
  private static final Singleton instance = new Singleton(); 
  private int count = 0; 
  private Singleton() {} 
  public static Singleton getInstance() { 
    return instance; 
  }  public int Add() int { 
    this.count++; 
    return this.count; 
  }} 

代碼很簡單，不過多解釋。直接看懶漢式的實現：

public class Singleton { 
  private static Singleton instance = null; 
  private int count = 0; 
  private Singleton() {} 
  public static synchronized Singleton getInstance() { 
    if (instance == null) { 
      instance = new Singleton(); 
    }    return instance; 
  }  public int Add() int { 
    this.count++; 
    return this.count; 
  }} 

主要區別在于 getInstance 的實現，要注意 synchronized ，避免多線程時出現問題。

3、單例模式的 Go 實現

在 Go 語言中如何實現單例模式，類比 Java 代碼實現。

// 餓漢式單例模式 
package singleton 
type singleton struct {  count int 
}var Instance = new(singleton)func (s *singleton) Add() int { 
  s.count++  return s.count 
} 

前面說了，Go 只支持部分面向對象的特性，因此看起來有點不太一樣：

• 類(結構體 singleton)本身非公開(小寫字母開頭，非導出);
• 沒有提供導出的 GetInstance 工廠方法(Go 沒有靜態方法)，而是直接提供包級導出變量 Instance;

這樣使用：

c := singleton.Instance.Add() 

看看懶漢式單例模式在 Go 中如何實現：

// 懶漢式單例模式 
package singleton 
import ( "sync" 
)type singleton struct { 
  count int}var (  instance *singleton  mutex sync.Mutex)func New() *singleton {  mutex.Lock()  if instance == nil { 
    instance = new(singleton)  }  mutex.Unlock()    return instance 
}func (s *singleton) Add() int {  s.count++  return s.count 
} 

代碼多了不少：

• 包級變量變成非導出(instance)，注意這里類型應該用指針，因為結構體的默認值不是 nil;
• 提供了工廠方法，按照 Go 的慣例，我們命名為 New();
• 多 goroutine 保護，對應 Java 的 synchronized，Go 使用 sync.Mutex;

關于懶漢式有一個“雙重檢查”，這是 C 語言的一種代碼模式。

在上面 New() 函數中，同步化(鎖保護)實際上只在 instance 變量第一次被賦值之前才有用。在 instance 變量有了值之后，同步化實際上變成了一個不必要的瓶頸。如果能夠有一個方法去掉這個小小的額外開銷，不是更加完美嗎?因此出現了“雙重檢查”。看看 Go 如何實現“雙重檢查”，只看 New() 代碼：

func New() *singleton { 
  if instance == nil { // 第一次檢查（①） 
    // 這里可能有多于一個 goroutine 同時達到（②） 
    mutex.Lock() 
    // 這里每個時刻只會有一個 goroutine（③） 
    if instance == nil { // 第二次檢查（④） 
      instance = new(singleton) 
    } 
    mutex.Unlock() 
  } 
   
  return instance 
} 

有讀者可能看不懂上面代碼的意思，這里詳細解釋下。假設 goroutine X 和 Y 作為第一批調用者同時或幾乎同時調用 New 函數。

• 因為 goroutine X 和 Y 是第一批調用者，因此，當它們進入此函數時，instance 變量是 nil。因此 goroutine X 和 Y 會同時或幾乎同時到達位置 ①;
• 假設 goroutine X 會先達到位置 ②，并進入 mutex.Lock() 達到位置 ③。這時，由于 mutex.Lock 的同步限制，goroutine Y 無法到達位置 ③，而只能在位置 ② 等候;
• goroutine X 執行 instance = new(singleton) 語句，使得 instance 變量得到一個值，即對 singleton 實例的引用。此時，goroutine Y 只能繼續在位置 ② 等候;
• goroutine X 釋放鎖，返回 instance，退出 New 函數;
• goroutine Y 進入 mutex.Lock()，到達位置 ③，進而到達位置 ④。由于 instance 變量已經不是 nil，因此 goroutine Y 釋放鎖，返回 instance 所引用的 singleton 實例(也就是 goroutine X 鎖創建的 singleton 實例)，退出 New 函數;

到這里，goroutine X 和 Y 得到了同一個 singleton 實例。可見上面的 New 函數中，鎖僅用來避免多個 goroutine 同時實例化 singleton。

相比前面的版本，雙重檢查版本，只要 instance 實例化后，鎖永遠不會執行了，而前面版本每次調用 New 獲取實例都需要執行鎖。性能很顯然，我們可以基準測試來驗證：(雙重檢查版本 New 重命名為 New2)

package singleton_test 
import ( "testing" 
 "github.com/polaris1119/go-demo/singleton" 
)func BenchmarkNew(b *testing.B) { 
 for i := 0; i < b.N; i++ { 
  singleton.New() }}func BenchmarkNew2(b *testing.B) { 
 for i := 0; i < b.N; i++ { 
  singleton.New2() }} 

因為是單例，所以兩個基準測試需要分別執行。

New1 的結果：

$ go test -benchmem -bench ^BenchmarkNew$ github.com/polaris1119/go-demo/singleton 
goos: darwin 
goarch: amd64 
pkg: github.com/polaris1119/go-demo/singleton 
BenchmarkNew-8    80470467         14.0 ns/op        0 B/op        0 allocs/op 
PASS 
ok   github.com/polaris1119/go-demo/singleton 1.151s 

New2 的結果：

$ go test -benchmem -bench ^BenchmarkNew2$ github.com/polaris1119/go-demo/singleton 
goos: darwin 
goarch: amd64 
pkg: github.com/polaris1119/go-demo/singleton 
BenchmarkNew2-8    658810392          1.80 ns/op        0 B/op        0 allocs/op 
PASS 
ok   github.com/polaris1119/go-demo/singleton 1.380s 

New2 快十幾倍。

細心得讀者會發現，在 Go 中，餓漢式還有一種更好的實現方式，那就是使用 sync.Once，這是 Go 實現懶漢式更標準的做法。核心代碼如下(New3)：

var once sync.Once 
func New3() *singleton {    once.Do(func() { 
        instance = new(singleton) 
    })    return instance 
} 

通過基準測試，它的性能和 New2 差不多。

此外，無論是 Java 還是 Go，都有一些其他“黑魔法”，比如 Go 語言中，利用 init 函數來初始化唯一的單例。不過一般都不太建議，還是常規方式來。

Go 語言單例模式，一般推薦優先考慮使用餓漢式。但如果初始化比較耗時，懶漢式延遲初始化是更好的選擇。

4、使用場景

在 Go 語言中，如下兩個場景比較適合使用單例模式：

• 數據庫實例。只想創建一個 DB 對象實例，該實例在整個應用程序中使用。
• 日志實例。同樣，只創建一個 Logger 的實例，并且在整個應用程序中使用它。