希望你看到這篇文章的時(shí)候還是在公交車和地鐵上正在上下班的時(shí)間,，我希望我的這篇文章可以讓你利用這段時(shí)間了解一門語言,。當(dāng)然,，希望你不會(huì)因?yàn)榭次业奈恼露e(cuò)過站,。呵呵,。
如果你還不了解 Go 語言的語法,，還請(qǐng)你移步先看一下上篇——《Go 語言簡(jiǎn)介（上）：語法》
goroutine
GoRoutine 主要是使用 go 關(guān)鍵字來調(diào)用函數(shù),，你還可以使用匿名函數(shù),，如下所示：
package main
import "fmt"
func f (msg string) {
fmt.Println (msg)
}
func main (){
go f ("goroutine")
go func (msg string) {
fmt.Println (msg)
}("going")
}
我們?cè)賮砜匆粋€(gè)示例,，下面的代碼中包括很多內(nèi)容，包括時(shí)間處理,，隨機(jī)數(shù)處理,，還有 goroutine 的代碼。如果你熟悉C語言,，你應(yīng)該會(huì)很容易理解下面的代碼,。
你可以簡(jiǎn)單的把 go 關(guān)鍵字調(diào)用的函數(shù)想像成 pthread_create。下面的代碼使用 for 循環(huán)創(chuàng)建了 3 個(gè)線程，每個(gè)線程使用一個(gè)隨機(jī)的 Sleep 時(shí)間,，然后在 routine ()函數(shù)中會(huì)輸出一些線程執(zhí)行的時(shí)間信息,。
package main
import "fmt"
import "time"
import "math/rand"
func routine (name string, delay time.Duration) {
t0 := time.Now ()
fmt.Println (name, " start at ", t0)
time.Sleep(delay)
t1 := time.Now ()
fmt.Println (name, " end at ", t1)
fmt.Println (name, " lasted ", t1.Sub(t0))
}
func main () {
//生成隨機(jī)種子
rand.Seed (time.Now () .Unix ())
var name string
for i:=0; i<3; i++{
name = fmt.Sprintf("go_%02d", i) //生成 ID
//生成隨機(jī)等待時(shí)間，從0-4秒
go routine (name, time.Duration (rand.Intn (5)) * time.Second)
}
//讓主進(jìn)程停住,，不然主進(jìn)程退了,，goroutine 也就退了
var input string
fmt.Scanln (&input)
fmt.Println ("done")
}
運(yùn)行的結(jié)果可能是：
go_00 start at 2012-11-04 19:46:35.8974894 +0800 +0800
go_01 start at 2012-11-04 19:46:35.8974894 +0800 +0800
go_02 start at 2012-11-04 19:46:35.8974894 +0800 +0800
go_01 end at 2012-11-04 19:46:36.8975894 +0800 +0800
go_01 lasted 1.0001s
go_02 end at 2012-11-04 19:46:38.8987895 +0800 +0800
go_02 lasted 3.0013001s
go_00 end at 2012-11-04 19:46:39.8978894 +0800 +0800
go_00 lasted 4.0004s
goroutine 的并發(fā)安全性
關(guān)于 goroutine，我試了一下,，無論是 Windows 還是 Linux,，基本上來說是用操作系統(tǒng)的線程來實(shí)現(xiàn)的。不過,，goroutine 有個(gè)特性,，也就是說，如果一個(gè) goroutine 沒有被阻塞,，那么別的 goroutine 就不會(huì)得到執(zhí)行,。這并不是真正的并發(fā)，如果你要真正的并發(fā),，你需要在你的 main 函數(shù)的第一行加上下面的這段代碼：
import "runtime"
...
runtime.GOMAXPROCS (4)
還是讓我們來看一個(gè)有并發(fā)安全性問題的示例（注意：我使用了C的方式來寫這段 Go 的程序）
這是一個(gè)經(jīng)常出現(xiàn)在教科書里賣票的例子,，我啟了 5 個(gè) goroutine 來賣票，賣票的函數(shù) sell_tickets 很簡(jiǎn)單,，就是隨機(jī)的 sleep 一下,，然后對(duì)全局變量 total_tickets 作減一操作。
package main
import "fmt"
import "time"
import "math/rand"
import "runtime"
var total_tickets int32 = 10;
func sell_tickets (i int){
for{
if total_tickets > 0 { //如果有票就賣
time.Sleep( time.Duration (rand.Intn (5)) * time.Millisecond)
total_tickets-- //賣一張票
fmt.Println ("id:", i, " ticket:", total_tickets)
}else{
break
}
}
}
func main () {
runtime.GOMAXPROCS (4) //我的電腦是 4 核處理器,，所以我設(shè)置了4
rand.Seed (time.Now () .Unix ()) //生成隨機(jī)種子
for i := 0; i < 5; i++ { //并發(fā) 5 個(gè) goroutine 來賣票
go sell_tickets (i)
}
//等待線程執(zhí)行完
var input string
fmt.Scanln (&input)
fmt.Println (total_tickets, "done") //退出時(shí)打印還有多少票
}
這個(gè)程序毋庸置疑有并發(fā)安全性問題,，所以執(zhí)行起來你會(huì)看到下面的結(jié)果：
$go run sell_tickets.go
id: 0 ticket: 9
id: 0 ticket: 8
id: 4 ticket: 7
id: 1 ticket: 6
id: 3 ticket: 5
id: 0 ticket: 4
id: 3 ticket: 3
id: 2 ticket: 2
id: 0 ticket: 1
id: 3 ticket: 0
id: 1 ticket: -1
id: 4 ticket: -2
id: 2 ticket: -3
id: 0 ticket: -4
-4 done
可見，我們需要使用上鎖,，我們可以使用互斥量來解決這個(gè)問題,。下面的代碼，我只列出了修改過的內(nèi)容：
package main
import "fmt"
import "time"
import "math/rand"
import "sync"
import "runtime"
var total_tickets int32 = 10;
var mutex = &sync.Mutex{} //可簡(jiǎn)寫成：var mutex sync.Mutex
func sell_tickets (i int){
for total_tickets>0 {
mutex.Lock()
if total_tickets > 0 {
time.Sleep( time.Duration (rand.Intn (5)) * time.Millisecond)
total_tickets--
fmt.Println (i, total_tickets)
}
mutex.Unlock ()
}
}
.......
......
原子操作
說到并發(fā)就需要說說原子操作,，相信大家還記得我寫的那篇《無鎖隊(duì)列的實(shí)現(xiàn)》一文,，里面說到了一些 CAS – CompareAndSwap 的操作。Go 語言也支持,。你可以看一下相當(dāng)?shù)奈臋n
我在這里就舉一個(gè)很簡(jiǎn)單的示例：下面的程序有 10 個(gè) goroutine,，每個(gè)會(huì)對(duì) cnt 變量累加 20 次，所以,，最后的 cnt 應(yīng)該是 200,。如果沒有 atomic 的原子操作，那么 cnt 將有可能得到一個(gè)小于 200 的數(shù),。
下面使用了 atomic 操作,，所以是安全的,。
package main
import "fmt"
import "time"
import "sync/atomic"
func main () {
var cnt uint32 = 0
for i := 0; i < 10; i++ {
go func () {
for i:=0; i<20; i++ {
time.Sleep(time.Millisecond)
atomic.AddUint32(&cnt, 1)
}
}()
}
time.Sleep(time.Second)//等一秒鐘等 goroutine 完成
cntFinal := atomic.LoadUint32(&cnt)//取數(shù)據(jù)
fmt.Println ("cnt:", cntFinal)
}
這樣的函數(shù)還有很多，參看 go 的 atomic 包文檔（被墻）
Channel 信道
Channal 是什么,？Channal 就是用來通信的,，就像 Unix 下的管道一樣，在 Go 中是這樣使用 Channel 的,。
下面的程序演示了一個(gè) goroutine 和主程序通信的例程,。這個(gè)程序足夠簡(jiǎn)單了。
package main
import "fmt"
func main () {
//創(chuàng)建一個(gè) string 類型的 channel
channel := make (chan string)
//創(chuàng)建一個(gè) goroutine 向 channel 里發(fā)一個(gè)字符串
go func () { channel <- "hello" }()
msg := <- channel
fmt.Println (msg)
}
指定 channel 的 buffer
指定 buffer 的大小很簡(jiǎn)單,，看下面的程序：
package main
import "fmt"
func main () {
channel := make (chan string, 2)
go func () {
channel <- "hello"
channel <- "World"
}()
msg1 := <-channel
msg2 := <-channel
fmt.Println (msg1, msg2)
}
Channel 的阻塞
注意,，channel 默認(rèn)上是阻塞的，也就是說,，如果 Channel 滿了，就阻塞寫,，如果 Channel 空了,，就阻塞讀。于是,，我們就可以使用這種特性來同步我們的發(fā)送和接收端,。
下面這個(gè)例程說明了這一點(diǎn)，代碼有點(diǎn)亂,，不過我覺得不難理解,。
package main
import "fmt"
import "time"
func main () {
channel := make (chan string) //注意: buffer 為1
go func () {
channel <- "hello"
fmt.Println ("write \"hello\" done!")
channel <- "World" //Reader 在 Sleep，這里在阻塞
fmt.Println ("write \"World\" done!")
fmt.Println ("Write go sleep...")
time.Sleep(3*time.Second)
channel <- "channel"
fmt.Println ("write \"channel\" done!")
}()
time.Sleep(2*time.Second)
fmt.Println ("Reader Wake up...")
msg := <-channel
fmt.Println ("Reader: ", msg)
msg = <-channel
fmt.Println ("Reader: ", msg)
msg = <-channel //Writer 在 Sleep,，這里在阻塞
fmt.Println ("Reader: ", msg)
}
上面的代碼輸出的結(jié)果如下：
Reader Wake up...
Reader: hello
write "hello" done!
write "World" done!
Write go sleep...
Reader: World
write "channel" done!
Reader: channel
Channel 阻塞的這個(gè)特性還有一個(gè)好處是,，可以讓我們的 goroutine 在運(yùn)行的一開始就阻塞在從某個(gè) channel 領(lǐng)任務(wù)，這樣就可以作成一個(gè)類似于線程池一樣的東西,。關(guān)于這個(gè)程序我就不寫了,。我相信你可以自己實(shí)現(xiàn)的。
多個(gè) Channel 的 select
package main
import "time"
import "fmt"
func main () {
//創(chuàng)建兩個(gè) channel - c1 c2
c1 := make (chan string)
c2 := make (chan string)
//創(chuàng)建兩個(gè) goruntine 來分別向這兩個(gè) channel 發(fā)送數(shù)據(jù)
go func () {
time.Sleep(time.Second * 1)
c1 <- "Hello"
}()
go func () {
time.Sleep(time.Second * 1)
c2 <- "World"
}()
//使用 select 來偵聽兩個(gè) channel
for i := 0; i < 2; i++ {
select {
case msg1 := <-c1:
fmt.Println ("received", msg1)
case msg2 := <-c2:
fmt.Println ("received", msg2)
}
}
}
注意：上面的 select 是阻塞的,，所以,，才搞出 ugly 的 for i <2這種東西。
Channel select 阻塞的 Timeout
解決上述那個(gè) for 循環(huán)的問題,，一般有兩種方法：一種是阻塞但有 timeout,，一種是無阻塞。我們來看看如果給 select 設(shè)置上 timeout 的,。
for {
timeout_cnt := 0
select {
case msg1 := <-c1:
fmt.Println ("msg1 received", msg1)
case msg2 := <-c2:
fmt.Println ("msg2 received", msg2)
case <-time.After (time.Second * 30)：
fmt.Println ("Time Out")
timout_cnt++
}
if time_cnt > 3 {
break
}
}
上面代碼中高亮的代碼主要是用來讓 select 返回的,，注意 case 中的 time.After 事件。
Channel 的無阻塞
好,，我們?cè)賮砜纯礋o阻塞的 channel,，其實(shí)也很簡(jiǎn)單,，就是在 select 中加入 default，如下所示：
for {
select {
case msg1 := <-c1:
fmt.Println ("received", msg1)
case msg2 := <-c2:
fmt.Println ("received", msg2)
default: //default 會(huì)導(dǎo)致無阻塞
fmt.Println ("nothing received!")
time.Sleep(time.Second)
}
}
Channel 的關(guān)閉
關(guān)閉 Channel 可以通知對(duì)方內(nèi)容發(fā)送完了,，不用再等了,。參看下面的例程：
package main
import "fmt"
import "time"
import "math/rand"
func main () {
channel := make (chan string)
rand.Seed (time.Now () .Unix ())
//向 channel 發(fā)送隨機(jī)個(gè)數(shù)的 message
go func () {
cnt := rand.Intn (10)
fmt.Println ("message cnt :", cnt)
for i:=0; i<cnt; i++{
channel <- fmt.Sprintf("message-%2d", i)
}
close(channel) //關(guān)閉 Channel
}()
var more bool = true
var msg string
for more {
select{
//channel 會(huì)返回兩個(gè)值，一個(gè)是內(nèi)容,，一個(gè)是還有沒有內(nèi)容
case msg, more = <- channel:
if more {
fmt.Println (msg)
}else{
fmt.Println ("channel closed!")
}
}
}
}
定時(shí)器
Go 語言中可以使用 time.NewTimer 或 time.NewTicker 來設(shè)置一個(gè)定時(shí)器,，這個(gè)定時(shí)器會(huì)綁定在你的當(dāng)前 channel 中，通過 channel 的阻塞通知機(jī)器來通知你的程序,。
下面是一個(gè) timer 的示例,。
package main
import "time"
import "fmt"
func main () {
timer := time.NewTimer (2*time.Second)
<- timer.C
fmt.Println ("timer expired!")
}
上面的例程看起來像一個(gè) Sleep，是的,，不過 Timer 是可以 Stop 的,。你需要注意 Timer 只通知一次。如果你要像C中的 Timer 能持續(xù)通知的話,，你需要使用 Ticker,。下面是 Ticker 的例程：
package main
import "time"
import "fmt"
func main () {
ticker := time.NewTicker (time.Second)
for t := range ticker.C {
fmt.Println ("Tick at", t)
}
}
上面的這個(gè) ticker 會(huì)讓你程序進(jìn)入死循環(huán)，我們應(yīng)該放其放在一個(gè) goroutine 中,。下面這個(gè)程序結(jié)合了 timer 和 ticker
package main
import "time"
import "fmt"
func main () {
ticker := time.NewTicker (time.Second)
go func () {
for t := range ticker.C {
fmt.Println (t)
}
}()
//設(shè)置一個(gè) timer,，10鈔后停掉 ticker
timer := time.NewTimer (10*time.Second)
<- timer.C
ticker.Stop ()
fmt.Println ("timer expired!")
}
Socket 編程
下面是我嘗試的一個(gè) Echo Server 的 Socket 代碼，感覺還是挺簡(jiǎn)單的,。
Server 端
package main
import (
"net"
"fmt"
"io"
)
const RECV_BUF_LEN = 1024
func main () {
listener, err := net.Listen("tcp", "0.0.0.0:6666")//偵聽在 6666 端口
if err != nil {
panic ("error listening:"+err.Error ())
}
fmt.Println ("Starting the server")
for {
conn, err := listener.Accept() //接受連接
if err != nil {
panic ("Error accept:"+err.Error ())
}
fmt.Println ("Accepted the Connection :", conn.RemoteAddr ())
go EchoServer (conn)
}
}
func EchoServer (conn net.Conn) {
buf := make ([]byte, RECV_BUF_LEN)
defer conn.Close()
for {
n, err := conn.Read(buf);
switch err {
case nil:
conn.Write( buf[0:n] )
case io.EOF:
fmt.Printf("Warning: End of data: %s \n", err);
return
default:
fmt.Printf("Error: Reading data : %s \n", err);
return
}
}
}
Client 端
package main
import (
"fmt"
"time"
"net"
)
const RECV_BUF_LEN = 1024
func main () {
conn,err := net.Dial ("tcp", "127.0.0.1:6666")
if err != nil {
panic (err.Error ())
}
defer conn.Close()
buf := make ([]byte, RECV_BUF_LEN)
for i := 0; i < 5; i++ {
//準(zhǔn)備要發(fā)送的字符串
msg := fmt.Sprintf("Hello World, %03d", i)
n, err := conn.Write([]byte (msg))
if err != nil {
println ("Write Buffer Error:", err.Error ())
break
}
fmt.Println (msg)
//從服務(wù)器端收字符串
n, err = conn.Read(buf)
if err !=nil {
println ("Read Buffer Error:", err.Error ())
break
}
fmt.Println (string (buf[0:n]))
//等一秒鐘
time.Sleep(time.Second)
}
}
系統(tǒng)調(diào)用
Go 語言那么C,，所以，一定會(huì)有一些系統(tǒng)調(diào)用,。Go 語言主要是通過兩個(gè)包完成的,。一個(gè)是 os 包，一個(gè)是 syscall 包,。（注意,，鏈接被墻）
這兩個(gè)包里提供都是 Unix-Like 的系統(tǒng)調(diào)用，
- syscall 里提供了什么 Chroot/Chmod/Chmod/Chdir…,，Getenv/Getgid/Getpid/Getgroups/Getpid/Getppid…,，還有很多如 Inotify/Ptrace/Epoll/Socket/…的系統(tǒng)調(diào)用。
- os 包里提供的東西不多,，主要是一個(gè)跨平臺(tái)的調(diào)用,。它有三個(gè)子包，Exec（運(yùn)行別的命令）,， Signal（捕捉信號(hào)）和 User（通過 uid 查 name 之類的）
syscall 包的東西我不舉例了,，大家可以看看《Unix 高級(jí)環(huán)境編程》一書。
os 里的取幾個(gè)例：
環(huán)境變量
package main
import "os"
import "strings"
func main () {
os.Setenv ("WEB", "http://") //設(shè)置環(huán)境變量
println (os.Getenv ("WEB")) //讀出來
for _, env := range os.Environ () { //窮舉環(huán)境變量
e := strings.Split(env, "=")
println (e[0], "=", e[1])
}
}
執(zhí)行命令行
下面是一個(gè)比較簡(jiǎn)單的示例
package main
import "os/exec"
import "fmt"
func main () {
cmd := exec.Command ("ping", "127.0.0.1")
out, err := cmd.Output ()
if err!=nil {
println ("Command Error!", err.Error ())
return
}
fmt.Println (string (out))
}
正規(guī)一點(diǎn)的用來處理標(biāo)準(zhǔn)輸入和輸出的示例如下：
package main
import (
"strings"
"bytes"
"fmt"
"log"
"os/exec"
)
func main () {
cmd := exec.Command ("tr", "a-z", "A-Z")
cmd.Stdin = strings.NewReader ("some input")
var out bytes.Buffer
cmd.Stdout = &out
err := cmd.Run ()
if err != nil {
log.Fatal (err)
}
fmt.Printf("in all caps: %q\n", out.String ())
}
命令行參數(shù)
Go 語言中處理命令行參數(shù)很簡(jiǎn)單：(使用 os 的 Args 就可以了)
func main () {
args := os.Args
fmt.Println (args) //帶執(zhí)行文件的
fmt.Println (args[1:]) //不帶執(zhí)行文件的
}
在 Windows 下,，如果運(yùn)行結(jié)果如下：
C:\Projects\Go>go run args.go aaa bbb ccc ddd
[C:\Users\haoel\AppData\Local\Temp\go-build742679827\command-line-arguments\_
obj\a.out.exe aaa bbb ccc ddd]
[aaa bbb ccc ddd]
那么,，如果我們要搞出一些像 mysql -uRoot -hLocalhost -pPwd 或是像 cc -O3 -Wall -o a a.c 這樣的命令行參數(shù)我們?cè)趺崔k,？Go 提供了一個(gè) package 叫 flag 可以容易地做到這一點(diǎn)
package main
import "flag"
import "fmt"
func main () {
//第一個(gè)參數(shù)是“參數(shù)名”，第二個(gè)是“默認(rèn)值”,，第三個(gè)是“說明”,。返回的是指針
host := flag.String ("host", "", "a host name ")
port := flag.Int("port", 80, "a port number")
debug := flag.Bool ("d", false, "enable/disable debug mode")
//正式開始 Parse 命令行參數(shù)
flag.Parse ()
fmt.Println ("host:", *host)
fmt.Println ("port:", *port)
fmt.Println ("debug:", *debug)
}
執(zhí)行起來會(huì)是這個(gè)樣子：
#如果沒有指定參數(shù)名，則使用默認(rèn)值
$ go run flagtest.go
host:
port: 80
debug: false
#指定了參數(shù)名后的情況
$ go run flagtest.go -host=localhost -port=22 -d
host: localhost
port: 22
debug: true
#用法出錯(cuò)了（如：使用了不支持的參數(shù),，參數(shù)沒有=）
$ go build flagtest.go
$ ./flagtest -debug -host localhost -port=22
flag provided but not defined: -debug
Usage of flagtest:
-d=false: enable/disable debug mode
-host="": a host name
-port=80: a port number
exit status 2
感覺還是挺不錯(cuò)的吧,。
一個(gè)簡(jiǎn)單的 HTTP Server
代碼勝過千言萬語。呵呵,。這個(gè)小程序讓我又找回以前用C寫 CGI 的時(shí)光了,。（Go 的官方文檔是《Writing Web Applications》）
package main
import (
"fmt"
"net/http"
"io/ioutil"
"path/filepath"
)
const http_root = "/home/haoel//"
func main () {
http.HandleFunc ("/", rootHandler)
http.HandleFunc ("/view/", viewHandler)
http.HandleFunc ("/html/", htmlHandler)
http.ListenAndServe (":8080", nil)
}
//讀取一些 HTTP 的頭
func rootHandler (w http.ResponseWriter, r *http.Request) {
fmt.Fprintf (w, "rootHandler: %s\n", r.URL.Path)
fmt.Fprintf (w, "URL: %s\n", r.URL)
fmt.Fprintf (w, "Method: %s\n", r.Method)
fmt.Fprintf (w, "RequestURI: %s\n", r.RequestURI )
fmt.Fprintf (w, "Proto: %s\n", r.Proto)
fmt.Fprintf (w, "HOST: %s\n", r.Host)
}
//特別的 URL 處理
func viewHandler (w http.ResponseWriter, r *http.Request) {
fmt.Fprintf (w, "viewHandler: %s", r.URL.Path)
}
//一個(gè)靜態(tài)網(wǎng)頁的服務(wù)示例。（在 http_root 的 html 目錄下）
func htmlHandler (w http.ResponseWriter, r *http.Request) {
fmt.Printf("htmlHandler: %s\n", r.URL.Path)
filename := http_root + r.URL.Path
fileext := filepath.Ext (filename)
content, err := ioutil.ReadFile (filename)
if err != nil {
fmt.Printf(" 404 Not Found!\n")
w.WriteHeader (http.StatusNotFound)
return
}
var contype string
switch fileext {
case ".html", "htm":
contype = "text/html"
case ".css":
contype = "text/css"
case ".js":
contype = "application/javascript"
case ".png":
contype = "image/png"
case ".jpg", ".jpeg":
contype = "image/jpeg"
case ".gif":
contype = "image/gif"
default:
contype = "text/plain"
}
fmt.Printf("ext %s, ct = %s\n", fileext, contype)
w.Header () .Set ("Content-Type", contype)
fmt.Fprintf (w, "%s", content)
}
Go 的功能庫有很多,，大家自己慢慢看吧,。我再吐個(gè)槽——Go 的文檔真不好讀。例子太少了,。
先說這么多吧,。這是我周末兩天學(xué) Go 語言學(xué)到的東西，寫得太倉促了,，而且還有一些東西理解不到位，還大家請(qǐng)指正,！
