Go 語言簡介（下） - 特性
希望你看到這篇文章的時候還是在公交車和地鐵上正在上下班的時間，我希望我的這篇文章可以讓你利用這段時間了解一門語言。當然，希望你不會因為看我的文章而錯過站。呵呵。
如果你還不了解Go語言的語法，還請你移步先看一下上篇——《Go語言簡介（上）：語法》
goroutine
GoRoutine主要是使用go關鍵字來調用函數，你還可以使用匿名函數，如下所示：
package main
import "fmt"
func f(msg string) {
fmt.Println(msg)
}
func main(){
go f("goroutine")
go func(msg string) {
fmt.Println(msg)
}("going")
} 我們再來看一個示例，下面的代碼中包括很多內容，包括時間處理，隨機數處理，還有goroutine的代碼。如果你熟悉C語言，你應該會很容易理解下面的代碼。
你可以簡單的把go關鍵字調用的函數想像成pthread_create。下面的代碼使用for循環創建了3個線程，每個線程使用一個隨機的Sleep時間，然后在routine()函數中會輸出一些線程執行的時間信息。
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() {
//生成隨機種子
rand.Seed(time.Now().Unix())
var name string
for i:=0; i<3; i++{
name = fmt.Sprintf("go_%02d", i) //生成ID
//生成隨機等待時間，從0-4秒
go routine(name, time.Duration(rand.Intn(5)) * time.Second)
}
//讓主進程停住，不然主進程退了，goroutine也就退了
var input string
fmt.Scanln(&input)
fmt.Println("done")
} 運行的結果可能是：
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的并發安全性
關于goroutine，我試了一下，無論是Windows還是Linux，基本上來說是用操作系統的線程來實現的。不過，goroutine有個特性，也就是說，如果一個goroutine沒有被阻塞，那么別的goroutine就不會得到執行。這并不是真正的并發，如果你要真正的并發，你需要在你的main函數的第一行加上下面的這段代碼：
import "runtime" ... runtime.GOMAXPROCS(4)
還是讓我們來看一個有并發安全性問題的示例（注意：我使用了C的方式來寫這段Go的程序）
這是一個經常出現在教科書里賣票的例子，我啟了5個goroutine來賣票，賣票的函數sell_tickets很簡單，就是隨機的sleep一下，然后對全局變量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核處理器，所以我設置了4
rand.Seed(time.Now().Unix()) //生成隨機種子
for i := 0; i < 5; i++ { //并發5個goroutine來賣票
go sell_tickets(i)
}
//等待線程執行完
var input string
fmt.Scanln(&input)
fmt.Println(total_tickets, "done") //退出時打印還有多少票
} 這個程序毋庸置疑有并發安全性問題，所以執行起來你會看到下面的結果：
$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
可見，我們需要使用上鎖，我們可以使用互斥量來解決這個問題。下面的代碼，我只列出了修改過的內容：
package main
import "fmt"
import "time"
import "math/rand"
import "sync"
import "runtime"
var total_tickets int32 = 10;
var mutex = &sync.Mutex{} //可簡寫成：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()
}
}
.......
...... 原子操作
說到并發就需要說說原子操作，相信大家還記得我寫的那篇《無鎖隊列的實現》一文，里面說到了一些CAS – CompareAndSwap的操作。Go語言也支持。你可以看一下相當的文檔
我在這里就舉一個很簡單的示例：下面的程序有10個goroutine，每個會對cnt變量累加20次，所以，最后的cnt應該是200。如果沒有atomic的原子操作，那么cnt將有可能得到一個小于200的數。
下面使用了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)//取數據
fmt.Println("cnt:", cntFinal)
} 這樣的函數還有很多，參看go的atomic包文檔（被墻）
Channel 信道
Channal是什么？Channal就是用來通信的，就像Unix下的管道一樣，在Go中是這樣使用Channel的。
下面的程序演示了一個goroutine和主程序通信的例程。這個程序足夠簡單了。
package main
import "fmt"
func main() {
//創建一個string類型的channel
channel := make(chan string)
//創建一個goroutine向channel里發一個字符串
go func() { channel <- "hello" }()
msg := <- channel
fmt.Println(msg)
} 指定channel的buffer
指定buffer的大小很簡單，看下面的程序：
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默認上是阻塞的，也就是說，如果Channel滿了，就阻塞寫，如果Channel空了，就阻塞讀。于是，我們就可以使用這種特性來同步我們的發送和接收端。
下面這個例程說明了這一點，代碼有點亂，不過我覺得不難理解。
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)
} 上面的代碼輸出的結果如下：
Reader Wake up... Reader: hello write "hello" done! write "World" done! Write go sleep... Reader: World write "channel" done! Reader: channel
Channel阻塞的這個特性還有一個好處是，可以讓我們的goroutine在運行的一開始就阻塞在從某個channel領任務，這樣就可以作成一個類似于線程池一樣的東西。關于這個程序我就不寫了。我相信你可以自己實現的。
多個Channel的select
package main
import "time"
import "fmt"
func main() {
//創建兩個channel - c1 c2
c1 := make(chan string)
c2 := make(chan string)
//創建兩個goruntine來分別向這兩個channel發送數據
go func() {
time.Sleep(time.Second * 1)
c1 <- "Hello"
}()
go func() {
time.Sleep(time.Second * 1)
c2 <- "World"
}()
//使用select來偵聽兩個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
解決上述那個for循環的問題，一般有兩種方法：一種是阻塞但有timeout，一種是無阻塞。我們來看看如果給select設置上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的無阻塞
好，我們再來看看無阻塞的channel，其實也很簡單，就是在select中加入default，如下所示：
for {
select {
case msg1 := <-c1:
fmt.Println("received", msg1)
case msg2 := <-c2:
fmt.Println("received", msg2)
default: //default會導致無阻塞
fmt.Println("nothing received!")
time.Sleep(time.Second)
}
} Channel的關閉
關閉Channel可以通知對方內容發送完了，不用再等了。參看下面的例程：
package main
import "fmt"
import "time"
import "math/rand"
func main() {
channel := make(chan string)
rand.Seed(time.Now().Unix())
//向channel發送隨機個數的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) //關閉Channel
}()
var more bool = true
var msg string
for more {
select{
//channel會返回兩個值，一個是內容，一個是還有沒有內容
case msg, more = <- channel:
if more {
fmt.Println(msg)
}else{
fmt.Println("channel closed!")
}
}
}
} 定時器
Go語言中可以使用time.NewTimer或time.NewTicker來設置一個定時器，這個定時器會綁定在你的當前channel中，通過channel的阻塞通知機器來通知你的程序。
下面是一個timer的示例。
package main
import "time"
import "fmt"
func main() {
timer := time.NewTimer(2*time.Second)
<- timer.C
fmt.Println("timer expired!")
} 上面的例程看起來像一個Sleep，是的，不過Timer是可以Stop的。你需要注意Timer只通知一次。如果你要像C中的Timer能持續通知的話，你需要使用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)
}
} 上面的這個ticker會讓你程序進入死循環，我們應該放其放在一個goroutine中。下面這個程序結合了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)
}
}()
//設置一個timer，10鈔后停掉ticker
timer := time.NewTimer(10*time.Second)
<- timer.C
ticker.Stop()
fmt.Println("timer expired!")
} Socket編程
下面是我嘗試的一個Echo Server的Socket代碼，感覺還是挺簡單的。
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
}
}
}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++ {
//準備要發送的字符串
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)
//從服務器端收字符串
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)
}
} 系統調用
Go語言那么C，所以，一定會有一些系統調用。Go語言主要是通過兩個包完成的。一個是os包，一個是syscall包。（注意，鏈接被墻）
這兩個包里提供都是Unix-Like的系統調用，
- syscall里提供了什么Chroot/Chmod/Chmod/Chdir…，Getenv/Getgid/Getpid/Getgroups/Getpid/Getppid…，還有很多如Inotify/Ptrace/Epoll/Socket/…的系統調用。
- os包里提供的東西不多，主要是一個跨平臺的調用。它有三個子包，Exec（運行別的命令）, Signal（捕捉信號）和User（通過uid查name之類的）
syscall包的東西我不舉例了，大家可以看看《Unix高級環境編程》一書。
os里的取幾個例：
環境變量
package main
import "os"
import "strings"
func main() {
os.Setenv("WEB", "http://coolshell.cn") //設置環境變量
println(os.Getenv("WEB")) //讀出來
for _, env := range os.Environ() { //窮舉環境變量
e := strings.Split(env, "=")
println(e[0], "=", e[1])
}
} 執行命令行
下面是一個比較簡單的示例
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))
} 正規一點的用來處理標準輸入和輸出的示例如下：
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())
} 命令行參數
Go語言中處理命令行參數很簡單：(使用os的Args就可以了)
func main() {
args := os.Args
fmt.Println(args) //帶執行文件的
fmt.Println(args[1:]) //不帶執行文件的
} 在Windows下，如果運行結果如下：
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 這樣的命令行參數我們怎么辦？Go提供了一個package叫flag可以容易地做到這一點
package main
import "flag"
import "fmt"
func main() {
//第一個參數是“參數名”，第二個是“默認值”，第三個是“說明”。返回的是指針
host := flag.String("host", "coolshell.cn", "a host name ")
port := flag.Int("port", 80, "a port number")
debug := flag.Bool("d", false, "enable/disable debug mode")
//正式開始Parse命令行參數
flag.Parse()
fmt.Println("host:", *host)
fmt.Println("port:", *port)
fmt.Println("debug:", *debug)
} 執行起來會是這個樣子：
#如果沒有指定參數名，則使用默認值 $ go run flagtest.go host: coolshell.cn port: 80 debug: false #指定了參數名后的情況 $ go run flagtest.go -host=localhost -port=22 -d host: localhost port: 22 debug: true #用法出錯了（如：使用了不支持的參數，參數沒有=） $ 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="coolshell.cn": a host name -port=80: a port number exit status 2
感覺還是挺不錯的吧。
一個簡單的HTTP Server
代碼勝過千言萬語。呵呵。這個小程序讓我又找回以前用C寫CGI的時光了。（Go的官方文檔是《Writing Web Applications》）
package main
import (
"fmt"
"net/http"
"io/ioutil"
"path/filepath"
)
const http_root = "/home/haoel/coolshell.cn/"
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)
}
//一個靜態網頁的服務示例。（在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的功能庫有很多，大家自己慢慢看吧。我再吐個槽——Go的文檔真不好讀。例子太少了。
先說這么多吧。這是我周末兩天學Go語言學到的東西，寫得太倉促了，而且還有一些東西理解不到位，還大家請指正！
本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！