多執行緒，通道，讀寫鎖（單寫多讀），隨機（洗牌），是本文涉及的主要知識點。
先看一下做出來的效果，因為是實驗程式，跟真實的鬥地主還是有差距，理解萬歲！
[發牌員]：洗牌咯。
刷刷刷...
[發牌員]：牌洗好了。
[發牌員]：開始發牌。
[發牌員]：每個人17張牌。
[發牌員]：搶地主。
[fang]：哈哈，我是地主！
fang的牌是[♣9 ♦9 ♥A ♠9 ♣6 ♣5 ♦3 ♣10 ♥5 ♣8 ♠Q ♠A ♠8 ♦4 ♥4 ♦K ♥7 ♣A ♠K ♥3]，共20張。
dong的牌是[大王 ♦8 ♠5 小王 ♠6 ♣Q ♠10 ♣7 ♠3 ♦A ♦Q ♥J ♣K ♥6 ♥9 ♥Q ♣2]，共17張。
er的牌是[♣A ♠K ♥3 ♥2 ♠4 ♦2 ♦5 ♥K ♦10 ♠2 ♥8 ♦6 ♣4 ♦J ♣3 ♣J ♠7]，共17張。
[fang]：我開始出牌了。
[er]：我開始出牌了。
[dong]：我開始出牌了。
贏家是er。
基本流程是洗牌->發牌->搶地主->打牌->gg。
哈哈這個程式的精髓是，由於時(lan)間(de)有(xie)限(le)，打牌是哪個執行緒搶到了就出牌，直到牌出完了，就贏了。（多執行緒寫鬥地主，是我大學作業系統課程的實驗專案，當時是完整實現了鬥地主演算法的，用的是C++和MFC，可以在介面上互動打牌）
邊看程式碼變講。
主函式
func main() {
// 洗牌
cards := shuffle()
// 發牌
dealCards := deal(cards)
// 搶地主
fmt.Println("[發牌員]：搶地主。")
go player(order[0], dealCards[0])
go player(order[1], dealCards[1])
go player(order[2], dealCards[2])
// Winner
winner := <-winner
fmt.Printf("贏家是%s。\n", winner)
}
解析：
1.main裡面是打牌的步驟，洗牌，發牌，搶地主，打牌，gg。
2.用go player()，開了3個執行緒，也就是3個玩家。
3.發牌的時候，是留了3張底牌的，存在通道“bottom”裡面，搶地主的時候，3個執行緒就去取，誰先取到誰就是地主。
4.打牌打到最後，會往另外一個通道“winner”裡面寫值，誰先打完，就把自己的name存進去。
5.3個玩家在打牌的時候，main是阻塞的，等待從通道“winner”讀取值，有玩家打完了，通道“winner”有值了，就啟用。
洗牌函式
func shuffle() []string {
fmt.Println("[發牌員]：洗牌咯。")
fmt.Println("刷刷刷...")
cards := cards()
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(cards), func(i, j int) {
cards[i], cards[j] = cards[j], cards[i]
})
fmt.Println("[發牌員]：牌洗好了。")
return cards
}
解析：
1.rand預設是假的隨機，因為不管執行多少次都是一樣的，需要設定種子，time.Now().UnixNano()，讓每次隨機結果都不同。
2.rand.Shuffle()洗牌，隨機交換2個牌的位置。
發牌函式
func deal(cards []string) [][]string {
fmt.Println("[發牌員]：開始發牌。")
var dealCards [][]string
dealCards = append(dealCards, cards[0:17])
dealCards = append(dealCards, cards[17:34])
dealCards = append(dealCards, cards[34:51])
fmt.Println("[發牌員]：每個人17張牌。")
go leaveBottom(cards[51:54])
return dealCards
}
解析：
1.因為已經洗了牌了，直接先切3份牌出來，每份17張。
2.留了3張底牌，放到通道“bottom”中。
3.如果這裡不再開執行緒，會發生死鎖！因為main本身也是個執行緒，直接存通道的話，會把main阻塞，直到有執行緒把通道的值讀出去；而main阻塞後，是無法繼續執行後面的程式碼的，也就無法再起3個玩家執行緒來讀值了，就會發生死鎖。
4.所以leaveBottom()起了一個單獨的執行緒。
Desk牌桌
type Desk struct {
mutex sync.RWMutex
playCards []string
}
func (d *Desk) write(card string) {
d.mutex.Lock()
defer d.mutex.Unlock()
d.playCards = append(d.playCards, card)
}
func (d *Desk) read() []string {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.playCards
}
解析：
1.定義了結構Desk，包括讀寫鎖和牌桌上打的牌。
2.定義了write()和read()2個函式，3個執行緒可以同時讀，但只能一次寫，也就是單寫多讀鎖。
player函式
func player(name string, hands []string) {
landlord := <-bottom
if len(landlord) > 0 {
fmt.Printf("[%s]：哈哈，我是地主！\n", name)
hands = append(hands, landlord...)
desk.write(name)
}
fmt.Printf("%s的牌是%s，共%d張。\n", name, hands, len(hands))
time.Sleep(time.Second)
i := 0
for true {
playCards := desk.read()
if playCards[len(playCards)-1] == name {
if i == 1 {
fmt.Printf("[%s]：我開始出牌了。\n", name)
}
desk.write(hands[i])
desk.write(order[(getOrderID(name)+1)%3])
i += 1
if i == len(hands) {
winner <- name
break
}
}
}
}
解析：
1.玩家函式，第一個引數是名字，第二個引數是手上拿的牌。
2.3個執行緒都有這樣一段程式碼。
3.首先從通道“bottom”讀取值，也就是搶地主。
4.搶到地主的玩家，會把底牌放到自己的手牌中，並且把自己的名字寫到牌桌上（根據名字來看該誰出牌），地主先出牌。
5.for true {}迴圈不停的出牌，從第一張到最後一張，先從牌桌上看是不是自己的名字，是自己的名字才輪到出牌。
6.牌出完了，就把自己的名字寫到通道“winner”，遊戲結束。
本文的程式只是為了實驗go的多執行緒特性，不具備可玩性，期待更多的同學請見諒。
如果需要原始碼的話，請到公眾號回覆「鬥地主」獲取哦。
版權申明：本文為博主原創文章，轉載請保留原文連結及作者。
如果您喜歡我寫的文章，請關注公眾號支援一下，謝謝哈哈哈。
