今天我要教大家一些無(wú)用技能，也可以叫它奇技淫巧或者黑魔法。用得好可以提升性能，用得不好就會(huì)招來(lái)惡魔，嘿嘿。

黑魔法導(dǎo)論

為了讓大家在學(xué)習(xí)了基礎(chǔ)黑魔法之后能有所悟，在必要的時(shí)候能創(chuàng)造出本文傳授之外的屬于自己的魔法，這里需要先給大家打好基礎(chǔ)。

學(xué)習(xí)Go語(yǔ)言黑魔法之前，需要先看清Go世界的本質(zhì)，你才能獲得像Neo一樣的能力。

在Go語(yǔ)言中，Slice本質(zhì)是什么呢？是一個(gè)reflect.SliceHeader結(jié)構(gòu)體和這個(gè)結(jié)構(gòu)體中Data字段所指向的內(nèi)存。String本質(zhì)是什么呢？是一個(gè)reflect.StringHeader結(jié)構(gòu)體和這個(gè)結(jié)構(gòu)體所指向的內(nèi)存。

在Go語(yǔ)言中，指針的本質(zhì)是什么呢？是unsafe.Pointer和uintptr。

當(dāng)你清楚了它們的本質(zhì)之后，你就可以隨意的玩弄它們，嘿嘿嘿。

第一式 - 獲得Slice和String的內(nèi)存數(shù)據(jù)

讓我小試身手，你有一個(gè)CGO接口要調(diào)用，需要你把一個(gè)字符串?dāng)?shù)據(jù)或者字節(jié)數(shù)組數(shù)據(jù)從Go這邊傳遞到C那邊，比如像這個(gè)：mysql/conn.go at master · funny/mysql · GitHub

查了各種教程和文檔，它們都告訴你要用C.GoString或C.GoBytes來(lái)轉(zhuǎn)換數(shù)據(jù)。

但是，當(dāng)你調(diào)用這兩個(gè)函數(shù)的時(shí)候，發(fā)生了什么事情呢？這時(shí)候Go復(fù)制了一份數(shù)據(jù)，然后再把新數(shù)據(jù)的地址傳給C，因?yàn)镚o不想冒任何風(fēng)險(xiǎn)。

你的C程序只是想一次性的用一下這些數(shù)據(jù)，也不得不做一次數(shù)據(jù)復(fù)制，這對(duì)于一個(gè)性能癖來(lái)說(shuō)是多麼可怕的一個(gè)事實(shí)！

這時(shí)候我們就需要一個(gè)黑魔法，來(lái)做到不拷貝數(shù)據(jù)又能把指針地址傳遞給C。

// returns &s[0], which is not allowed in go
func stringPointer(s string) unsafe.Pointer {
	p := (*reflect.StringHeader)(unsafe.Pointer(&s))
	return unsafe.Pointer(p.Data)
}

// returns &b[0], which is not allowed in go
func bytePointer(b []byte) unsafe.Pointer {
	p := (*reflect.SliceHeader)(unsafe.Pointer(&b))
	return unsafe.Pointer(p.Data)
}

以上就是黑魔法第一式，我們先去到Go字符串的指針，它本質(zhì)上是一個(gè)*reflect.StringHeader，但是Go告訴我們這是一個(gè)*string，我們告訴Go它同時(shí)也是一個(gè)unsafe.Pointer，Go說(shuō)好吧它是，于是你得到了unsafe.Pointer，接著你就躲過(guò)了Go的監(jiān)視，偷偷的把unsafe.Pointer轉(zhuǎn)成了*reflect.StringHeader。

有了*reflect.StringHeader，你很快就取到了Data字段指向的內(nèi)存地址，它就是Go保護(hù)著不想給你看到的隱秘所在，你把這個(gè)地址偷偷告訴給了C，于是C就愉快的偷看了Go的隱私。

第二式 - 把[]byte轉(zhuǎn)成string

你肯定要笑，要把[]byte轉(zhuǎn)成string還不簡(jiǎn)單？Go語(yǔ)言初學(xué)者都會(huì)的類(lèi)型轉(zhuǎn)換語(yǔ)法：string(b)。

但是你知道這么做的代價(jià)嗎？既然我們能隨意的玩弄SliceHeader和StringHeader，為什么我們不能造個(gè)string給Go呢？Go的內(nèi)部會(huì)不會(huì)就是這么做的呢？

先上個(gè)實(shí)驗(yàn)吧：

package labs28

import "testing"
import "unsafe"

func Test_ByteString(t *testing.T) {
	var x = []byte("Hello World!")
	var y = *(*string)(unsafe.Pointer(&x))
	var z = string(x)

	if y != z {
		t.Fail()
	}
}

func Benchmark_Normal(b *testing.B) {
	var x = []byte("Hello World!")
	for i := 0; i < b.N; i ++ {
		_ = string(x)
	}
}

func Benchmark_ByteString(b *testing.B) {
	var x = []byte("Hello World!")
	for i := 0; i < b.N; i ++ {
		_ = *(*string)(unsafe.Pointer(&x))
	}
}

這個(gè)實(shí)驗(yàn)先證明了我們可以用[]byte的數(shù)據(jù)造個(gè)string給Go。接著做了兩組Benchmark，分別測(cè)試了普通的類(lèi)型轉(zhuǎn)換和偽造string的效率。

結(jié)果如下：

$ go test -bench="."
PASS
Benchmark_Normal    20000000            63.4 ns/op
Benchmark_ByteString    2000000000           0.55 ns/op
ok      github.com/idada/go-labs/labs28 2.486s

喲西，顯然Go這次又為了穩(wěn)定性做了些復(fù)制數(shù)據(jù)之類(lèi)的事情了！這讓性能癖怎么能忍受！

我現(xiàn)在手頭有個(gè)[]byte，但是我想用strconv.Atoi()把它轉(zhuǎn)成字面含義對(duì)應(yīng)的整數(shù)值，竟然需要發(fā)生一次數(shù)據(jù)拷貝把它轉(zhuǎn)成string，比如像這樣：mysql/types.go at master · funny/mysql · GitHub，這實(shí)在不能忍啊！

出招：

// convert b to string without copy
func byteString(b []byte) string {
	return *(*string)(unsafe.Pointer(&b))
}

我們?nèi)〉絒]byte的指針，這次Go又告訴你它是*byte不是*string，你告訴它滾犢子這是unsafe.Pointer，Go這下又老實(shí)了，接著你很自在的把*byte轉(zhuǎn)成了*string，因?yàn)槟阒纑eflect.StringHeader和reflect.SliceHeader的結(jié)構(gòu)體只相差末尾一個(gè)字段，兩者的內(nèi)存是對(duì)齊的，沒(méi)必要再取Data字段了，直接轉(zhuǎn)吧。

于是，世界終于安寧了，嘿嘿。

第三式 - 結(jié)構(gòu)體和[]byte互轉(zhuǎn)

有一天，你想把一個(gè)簡(jiǎn)單的結(jié)構(gòu)體轉(zhuǎn)成二進(jìn)制數(shù)據(jù)保存起來(lái)，這時(shí)候你想到了encoding/gob和encoding/json，做了一下性能測(cè)試，你想到效率有沒(méi)有可能更高點(diǎn)？

于是你又試了encoding/binady，性能也還可以，但是你還不滿意。但是瓶頸在哪里呢？你恍然大悟，最高效的辦法就是完全不解析數(shù)據(jù)也不產(chǎn)生數(shù)據(jù)啊！

怎么做？是時(shí)候使用這個(gè)黑魔法了：

type MyStruct struct {
	A int
	B int
}

var sizeOfMyStruct = int(unsafe.Sizeof(MyStruct{}))

func MyStructToBytes(s *MyStruct) []byte {
	var x reflect.SliceHeader
	x.Len = sizeOfMyStruct
	x.Cap = sizeOfMyStruct
	x.Data = uintptr(unsafe.Pointer(s))
	return *(*[]byte)(unsafe.Pointer(&x))
}

func BytesToMyStruct(b []byte) *MyStruct {
	return (*MyStruct)(unsafe.Pointer(
		(*reflect.SliceHeader)(unsafe.Pointer(&b)).Data,
	))
}

這是個(gè)曲折但又熟悉的故事。你造了一個(gè)SliceHeader，想把它的Data字段指向你的結(jié)構(gòu)體，但是Go又告訴你不可以，你像往常那樣把Go提到一邊，你得到了unsafe.Pointer，但是這次Go有不死心，它告訴你Data是uintptr，unsafe.Pointer不是uintptr，你大腳把它踢開(kāi)，怒吼道：unsafe.Pointer就是uintptr，你少拿這些概念糊弄我，Go屁顛屁顛的跑開(kāi)了，現(xiàn)在你一馬平川的來(lái)到了函數(shù)的出口，Go竟然已經(jīng)在哪里等著你了！你上前三下五除二把它踢得遠(yuǎn)遠(yuǎn)的，順利的把手頭的SliceHeader轉(zhuǎn)成了[]byte。

過(guò)了一陣子，你拿到了一個(gè)[]byte，你知道需要把它轉(zhuǎn)成MyStruct來(lái)讀取其中的數(shù)據(jù)。Go這時(shí)候已經(jīng)完全不是你的對(duì)手了，它已經(jīng)洗好屁股在函數(shù)入口等你，你一行代碼就解決了它。

第四式 - 用CGO優(yōu)化GC

你已經(jīng)是Go世界的Neo，Go跟本沒(méi)辦法拿你怎么樣。但是有一天Go的GC突然抽風(fēng)了，原來(lái)這貨是不管對(duì)象怎么用的，每次GC都給來(lái)一遍人口普查，導(dǎo)致系統(tǒng)暫停時(shí)間很長(zhǎng)。

可是你是個(gè)性能癖，你把一堆數(shù)據(jù)都放在內(nèi)存里方便快速訪問(wèn)，你這時(shí)候很想再踢Go的屁股，但是你沒(méi)辦法，畢竟你還在Go的世界里，你現(xiàn)在得替它擦屁股了，你似乎看到Go躲在一旁偷笑。

你想到你手頭有CGO，可以輕易的用C申請(qǐng)到Go世界外的內(nèi)存，Go的GC不會(huì)掃描這部分內(nèi)存。

你還想到你可以用unsafe.Pointer將C的指針轉(zhuǎn)成Go的結(jié)構(gòu)體指針。于是一大批常駐內(nèi)存對(duì)象被你用這種方式轉(zhuǎn)成了Go世界的黑戶，Go的GC一下子輕松了下來(lái)。

但是你手頭還有很多Slice，于是你就利用C申請(qǐng)內(nèi)存給SliceHeader來(lái)構(gòu)造自己的Slice，于是你旗下的Slice紛紛轉(zhuǎn)成了Go世界的黑戶，Go的GC終于平靜了。

但好景總是不長(zhǎng)久，有一天Go世界突然崩潰了，只留下一句話：Segmentation Fault。你一下慫了，怎么段錯(cuò)誤了？

經(jīng)過(guò)一個(gè)通宵排查，你發(fā)現(xiàn)你管轄的黑戶對(duì)象竟然偷偷的跟Go世界的其它合法居民搞在一起，當(dāng)Go世界以為某個(gè)居民已經(jīng)消亡時(shí)，用GC回收了它的住所，但是你的地下世界卻認(rèn)為它還活著，還繼續(xù)訪問(wèn)它。

于是你廢了一番功夫斬?cái)嗔怂嘘P(guān)聯(lián)，世界暫時(shí)寧?kù)o了下來(lái)。

但是你已經(jīng)很累了，這時(shí)候你想起一句話：

為無(wú)為，則無(wú)不治