曰曰啪天天拍视频在线,午夜免费福利网站

　　希望你看到這篇文章的時候還是在公交車和地鐵上正在上下班的時間，我希望我的這篇文章可以讓你利用這段時間了解一門語言。當(dāng)然，希望你不會因為看我的文章而錯過站。呵呵。

　　如果你還不了解 Go 語言的語法，還請你移步先看一下上篇——《Go 語言簡介（上）：語法》

　　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")
}

　　我們再來看一個示例，下面的代碼中包括很多內(nèi)容，包括時間處理，隨機數(shù)處理，還有 goroutine 的代碼。如果你熟悉C語言，你應(yīng)該會很容易理解下面的代碼。

　　你可以簡單的把 go 關(guān)鍵字調(diào)用的函數(shù)想像成 pthread_create。下面的代碼使用 for 循環(huán)創(chuàng)建了 3 個線程，每個線程使用一個隨機的 Sleep 時間，然后在 routine ()函數(shù)中會輸出一些線程執(zhí)行的時間信息。

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")
}

　　運行的結(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)的線程來實現(xiàn)的。不過，goroutine 有個特性，也就是說，如果一個 goroutine 沒有被阻塞，那么別的 goroutine 就不會得到執(zhí)行。這并不是真正的并發(fā)，如果你要真正的并發(fā)，你需要在你的 main 函數(shù)的第一行加上下面的這段代碼：

import "runtime"
...
runtime.GOMAXPROCS (4)

　　還是讓我們來看一個有并發(fā)安全性問題的示例（注意：我使用了C的方式來寫這段 Go 的程序）

　　這是一個經(jīng)常出現(xiàn)在教科書里賣票的例子，我啟了 5 個 goroutine 來賣票，賣票的函數(shù) 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 核處理器，所以我設(shè)置了4
    rand.Seed (time.Now () .Unix ()) //生成隨機種子
 
    for i := 0; i < 5; i++ { //并發(fā) 5 個 goroutine 來賣票
         go sell_tickets (i)
    }
    //等待線程執(zhí)行完
    var input string
    fmt.Scanln (&input)
    fmt.Println (total_tickets, "done") //退出時打印還有多少票
}

　　這個程序毋庸置疑有并發(fā)安全性問題，所以執(zhí)行起來你會看到下面的結(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

　　可見，我們需要使用上鎖，我們可以使用互斥量來解決這個問題。下面的代碼，我只列出了修改過的內(nèi)容：

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 ()
    }
}
.......
......

　　原子操作

　　說到并發(fā)就需要說說原子操作，相信大家還記得我寫的那篇《無鎖隊列的實現(xiàn)》一文，里面說到了一些 CAS – CompareAndSwap 的操作。Go 語言也支持。你可以看一下相當(dāng)?shù)奈臋n

　　我在這里就舉一個很簡單的示例：下面的程序有 10 個 goroutine，每個會對 cnt 變量累加 20 次，所以，最后的 cnt 應(yīng)該是 200。如果沒有 atomic 的原子操作，那么 cnt 將有可能得到一個小于 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 的。

　　下面的程序演示了一個 goroutine 和主程序通信的例程。這個程序足夠簡單了。

package main
 
import "fmt"
 
func main () {
    //創(chuàng)建一個 string 類型的 channel
    channel := make (chan string)
 
    //創(chuàng)建一個 goroutine 向 channel 里發(fā)一個字符串
    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 默認(rèn)上是阻塞的，也就是說，如果 Channel 滿了，就阻塞寫，如果 Channel 空了，就阻塞讀。于是，我們就可以使用這種特性來同步我們的發(fā)送和接收端。

　　下面這個例程說明了這一點，代碼有點亂，不過我覺得不難理解。

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 阻塞的這個特性還有一個好處是，可以讓我們的 goroutine 在運行的一開始就阻塞在從某個 channel 領(lǐng)任務(wù)，這樣就可以作成一個類似于線程池一樣的東西。關(guān)于這個程序我就不寫了。我相信你可以自己實現(xiàn)的。

　　多個 Channel 的 select

package main
import "time"
import "fmt"
 
func main () {
    //創(chuàng)建兩個 channel - c1 c2
    c1 := make (chan string)
    c2 := make (chan string)
 
    //創(chuàng)建兩個 goruntine 來分別向這兩個 channel 發(fā)送數(shù)據(jù)
    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 循環(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 的無阻塞

　　好，我們再來看看無阻塞的 channel，其實也很簡單，就是在 select 中加入 default，如下所示：

for {
    select {
    case msg1 := <-c1:
        fmt.Println ("received", msg1)
    case msg2 := <-c2:
        fmt.Println ("received", msg2)
    default: //default 會導(dǎo)致無阻塞
        fmt.Println ("nothing received!")
        time.Sleep(time.Second)
    }
}

　　Channel 的關(guān)閉

　　關(guān)閉 Channel 可以通知對方內(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ā)送隨機個數(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 會返回兩個值，一個是內(nèi)容，一個是還有沒有內(nèi)容
        case msg, more = <- channel:
            if more {
                fmt.Println (msg)
            }else{
                fmt.Println ("channel closed!")
            }
        }
    }
}

　　定時器

　　Go 語言中可以使用 time.NewTimer 或 time.NewTicker 來設(shè)置一個定時器，這個定時器會綁定在你的當(dāng)前 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 能持續(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)
    }
}

　　上面的這個 ticker 會讓你程序進入死循環(huán)，我們應(yīng)該放其放在一個 goroutine 中。下面這個程序結(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è)置一個 timer，10鈔后停掉 ticker
    timer := time.NewTimer (10*time.Second)
    <- timer.C
 
    ticker.Stop ()
    fmt.Println ("timer expired!")
}

　　Socket 編程

　　下面是我嘗試的一個 Echo Server 的 Socket 代碼，感覺還是挺簡單的。

　　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，所以，一定會有一些系統(tǒng)調(diào)用。Go 語言主要是通過兩個包完成的。一個是 os 包，一個是 syscall 包。（注意，鏈接被墻）

　　這兩個包里提供都是 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 包里提供的東西不多，主要是一個跨平臺的調(diào)用。它有三個子包，Exec（運行別的命令）， Signal（捕捉信號）和 User（通過 uid 查 name 之類的）

　　syscall 包的東西我不舉例了，大家可以看看《Unix 高級環(huán)境編程》一書。

　　os 里的取幾個例：

　　環(huán)境變量

package main
 
import "os"
import "strings"
 
 
func main () {
    os.Setenv ("WEB", "http://coolshell.cn") //設(shè)置環(huán)境變量
    println (os.Getenv ("WEB")) //讀出來
 
    for _, env := range os.Environ () { //窮舉環(huán)境變量
        e := strings.Split(env, "=")
        println (e[0], "=", e[1])
    }
}

　　執(zhí)行命令行

　　下面是一個比較簡單的示例

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ī)一點的用來處理標(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ù)很簡單：(使用 os 的 Args 就可以了)

func main () {
    args := os.Args
    fmt.Println (args) //帶執(zhí)行文件的
    fmt.Println (args[1:]) //不帶執(zhí)行文件的
}

　　在 Windows 下，如果運行結(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ù)我們怎么辦？Go 提供了一個 package 叫 flag 可以容易地做到這一點

package main
import "flag"
import "fmt"
 
func main () {
 
    //第一個參數(shù)是“參數(shù)名”，第二個是“默認(rèn)值”，第三個是“說明”。返回的是指針
    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 命令行參數(shù)
    flag.Parse ()
 
    fmt.Println ("host:", *host)
    fmt.Println ("port:", *port)
    fmt.Println ("debug:", *debug)
}

　　執(zhí)行起來會是這個樣子：

#如果沒有指定參數(shù)名，則使用默認(rèn)值
$ go run flagtest.go
host: coolshell.cn
port: 80
debug: false
 
#指定了參數(shù)名后的情況
$ go run flagtest.go -host=localhost -port=22 -d
host: localhost
port: 22
debug: true
 
#用法出錯了（如：使用了不支持的參數(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="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)
}
 
//一個靜態(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 的功能庫有很多，大家自己慢慢看吧。我再吐個槽——Go 的文檔真不好讀。例子太少了。

　　先說這么多吧。這是我周末兩天學(xué) Go 語言學(xué)到的東西，寫得太倉促了，而且還有一些東西理解不到位，還大家請指正！

來自: coolshell.cn

本站僅提供存儲服務(wù)，所有內(nèi)容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點擊舉報。

九色国产,午夜在线视频,新黄色网址,九九色综合,天天做夜夜做久久做狠狠,天天躁夜夜躁狠狠躁2021a,久久不卡一区二区三区