GoLang初探

下面生成隨機數為例，以讓我們做一個會併發執行的隨機數生成器。

// 函式rand_generator_2，返回通道(Channel)

funcrand_generator_2() chan int {

         // 建立通道

         out := make(chan int)

         // 建立協程

         go func() {

                   for {

                            //向通道內寫入資料，如果無人讀取會等待

                            out <- rand.Int()

                   }

         }()

         return out

} 

funcmain() {

         // 生成隨機數作為一個服務

         rand_service_handler :=rand_generator_2()

         // 從服務中讀取隨機數並列印

         fmt.Printf("%d\n",<-rand_service_handler)

}

        上面的這段函式就可以併發執行了rand.Int()。有一點值得注意到函式的返回可以理解為一個“服務”。但我們需要獲取隨機資料時候，可以隨時向這個 服務取用，他已經為我們準備好了相應的資料，無需等待，隨要隨到。如果我們呼叫這個服務不是很頻繁，一個協程足夠滿足我們的需求了。但如果我們需要大量訪 問，怎麼辦？我們可以用下面介紹的多路複用技術，啟動若干生成器，再將其整合成一個大的服務。

// 函式rand_generator_3 ，返回通道(Channel)

funcrand_generator_3() chan int {

         // 建立兩個隨機數生成器服務

         rand_generator_1 := rand_generator_2()

         rand_generator_2 := rand_generator_2()

         //建立通道

         out := make(chan int)

         //建立協程

         go func() {

                   for {

                            //讀取生成器1中的資料，整合

                            out <-<-rand_generator_1

                   }

         }()

         go func() {

                   for {

                            //讀取生成器2中的資料，整合

                            out <-<-rand_generator_2

                   }

         }()

         return out

//一個查詢結構體

typequery struct {

         //引數Channel

         sql chan string

         //結果Channel

         result chan string

}

//執行Query

funcexecQuery(q query) {

         //啟動協程

         go func() {

                   //獲取輸入

                   sql := <-q.sql

                   //訪問資料庫，輸出結果通道

                   q.result <- "get" + sql

         }()

}

funcmain() {

         //初始化Query

         q :=

                   query{make(chan string, 1),make(chan string, 1)}

         //執行Query，注意執行的時候無需準備引數

         execQuery(q)

         //準備引數

         q.sql <- "select * fromtable"

         //獲取結果

         fmt.Println(<-q.result)

}

//建立計數器

sem :=make(chan int, N);

//FOR迴圈體

for i,xi:= range data {

         //建立協程

    go func (i int, xi float) {

        doSomething(i,xi);

                   //計數

        sem <- 0;

    } (i, xi);

}

// 等待迴圈結束

// Aconcurrent prime sieve

packagemain

// Sendthe sequence 2, 3, 4, ... to channel 'ch'.

funcGenerate(ch chan<- int) {

         for i := 2; ; i++ {

                  ch<- i // Send 'i' to channel 'ch'.

         }

}

// Copythe values from channel 'in' to channel 'out',

//removing those divisible by 'prime'.

funcFilter(in <-chan int, out chan<- int, prime int) {

         for {

                   i := <-in // Receive valuefrom 'in'.

                   if i%prime != 0 {

                            out <- i // Send'i' to 'out'.

                   }

         }

}

// Theprime sieve: Daisy-chain Filter processes.

funcmain() {

         ch := make(chan int) // Create a newchannel.

         go Generate(ch)      // Launch Generate goroutine.

         for i := 0; i < 10; i++ {

                   prime := <-ch

                   print(prime, "\n")

                   ch1 := make(chan int)

                   go Filter(ch, ch1, prime)

                   ch = ch1

         }

}

//共享變數有一個讀通道和一個寫通道組成

typesharded_var struct {

         reader chan int

         writer chan int

}

//共享變數維護協程

funcsharded_var_whachdog(v sharded_var) {

         go func() {

                   //初始值

                   var value int = 0

                   for {

                            //監聽讀寫通道，完成服務

                            select {

                            case value =<-v.writer:

                            case v.reader <-value:

                            }

                   }

         }()

}

funcmain() {

         //初始化，並開始維護協程

         v := sharded_var{make(chan int),make(chan int)}

         sharded_var_whachdog(v)

         //讀取初始值

         fmt.Println(<-v.reader)

         //寫入一個值

         v.writer <- 1

         //讀取新寫入的值

         fmt.Println(<-v.reader)

}

        協程和記憶體一樣，是系統的資源。對於記憶體，有自動垃圾回收。但是對於協程，沒有相應的回收機制。會不會若干年後，協程普及了，協程洩漏和記憶體洩漏一樣成為 程式設計師永遠的痛呢？一般而言，協程執行結束後就會銷燬。協程也會佔用記憶體，如果發生協程洩漏，影響和記憶體洩漏一樣嚴重。輕則拖慢程式，重則壓垮機器。

        C和C++都是沒有自動記憶體回收的程式設計語言，但只要有良好的程式設計習慣，就能解決規避問題。對於協程是一樣的，只要有好習慣就可以了。

        只有兩種情況會導致協程無法結束。一種情況是協程想從一個通道讀資料，但無人往這個通道寫入資料，或許這個通道已經被遺忘了。還有一種情況是程想往一個通道寫資料，可是由於無人監聽這個通道，該協程將永遠無法向下執行。下面分別討論如何避免這兩種情況。

        上面是個避免洩漏例子。使用超時避免讀堵塞，使用緩衝避免寫堵塞。