Go 語言簡介（下） - 特性

阿新 • • 發佈：2022-05-05

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: %qn", out.String())
}

命令列引數

Go語言中處理命令列引數很簡單：(使用os的Args就可以了)

func main() {
    args := os.Args
    fmt.Println(args) //帶執行檔案的
    fmt.Println(args[1:]) //不帶執行檔案的
}

在Windows下，如果執行結果如下：

C:ProjectsGo>go run args.go aaa bbb ccc ddd [C:UsershaoelAppDataLocalTempgo-build742679827command-line-arguments_ obja.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: %sn", r.URL.Path)
    fmt.Fprintf(w, "URL: %sn", r.URL)
    fmt.Fprintf(w, "Method: %sn", r.Method)
    fmt.Fprintf(w, "RequestURI: %sn", r.RequestURI )
    fmt.Fprintf(w, "Proto: %sn", r.Proto)
    fmt.Fprintf(w, "HOST: %sn", 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: %sn", 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 = %sn", fileext, contype)
    
    w.Header().Set("Content-Type", contype)
    fmt.Fprintf(w, "%s", content)
    
}

來自：http://coolshell.cn/articles/8489.html

Go 語言簡介（下） - 特性

goroutine

goroutine的併發安全性

原子操作

Channel 通道

定時器

Socket程式設計

系統呼叫

執行命令列

命令列引數

一個簡單的HTTP Server

Go 語言簡介（下） - 特性

[譯]為什麼你應該學習Go語言？（下）

Go 語言簡介（上）— 語法

[譯]為什麼你應該學習Go語言？（上）

Go語言反射（reflect）及應用

（零基礎）入門學習Python| 面向物件技術簡介（下）

go 語言基礎（上）

Go語言基礎（四）goroutine

資料結構go語言實現（2）字串與kmp演算法

Go語言對映（map）

c# Newtonsoft 六個值得使用的特性（下）

C語言成長之路45:選擇排序法（下）

Java高階特性 - JDBC（下）

Go語言核心36講（Go語言基礎知識一）--學習筆記

Go語言核心36講（Go語言基礎知識四）--學習筆記

如何系統學習C 語言（下）之檔案篇

如何系統學習C 語言（下）之預處理命令篇

Go modules基礎精進，六大核心概念全解析（下）

NLP論文解讀：無需模板且高效的語言微調模型（下）

GO語言基礎（結構+語法+型別+變數）

Go 語言簡介（下） - 特性

goroutine

goroutine的併發安全性

原子操作

Channel 通道

定時器

Socket程式設計

系統呼叫

執行命令列

命令列引數

一個簡單的HTTP Server

相關推薦