ch8: fix code format

2025-12-17 19:24:19 +08:00 · 2016-01-21 10:39:06 +08:00
parent 0b5ec941ed
commit b1730821fe
13 changed files with 393 additions and 404 deletions
--- a/ch8/ch8-01.md
+++ b/ch8/ch8-01.md
@@ -13,8 +13,8 @@ go f() // create a new goroutine that calls f(); don't wait

 在下面的例子中，main goroutine會計算第45個菲波那契數。由於計算函數使用了效率非常低的遞歸，所以會運行相當可觀的一段時間，在這期間我們想要讓用戶看到一個可見的標識來表明程序依然在正常運行，所以顯示一個動畵的小圖標：

+<u><i>gopl.io/ch8/spinner</i><u>
 ```go
-gopl.io/ch8/spinner
 func main() {
 	go spinner(100 * time.Millisecond)
 	const n = 45
@@ -37,7 +37,6 @@ func fib(x int) int {
 	}
 	return fib(x-1) + fib(x-2)
 }
-
 ```

 動畵顯示了幾秒之後，fib(45)的調用成功地返迴，併且打印結果：
--- a/ch8/ch8-02.md
+++ b/ch8/ch8-02.md
@@ -4,8 +4,8 @@

 我們的第一個例子是一個順序執行的時鐘服務器，它會每隔一秒鐘將當前時間寫到客戶端：

+<u><i>gopl.io/ch8/clock1</i></u>
 ```go
-gopl.io/ch8/clock1
 // Clock1 is a TCP server that periodically writes the time.
 package main

@@ -66,8 +66,8 @@ $ nc localhost 8000

 客戶端將服務器發來的時間顯示了出來，我們用Control+C來中斷客戶端的執行，在Unix繫統上，你會看到^C這樣的響應。如果你的繫統沒有裝nc這個工具，你可以用telnet來實現同樣的效果，或者也可以用我們下面的這個用go寫的簡單的telnet程序，用net.Dial就可以簡單地創建一個TCP連接：

+<u><i>gopl.io/ch8/netcat1</i></u>
 ```go
-gopl.io/ch8/netcat1
 // Netcat1 is a read-only TCP client.
 package main

@@ -114,8 +114,8 @@ killall命令是一個Unix命令行工具，可以用給定的進程名來殺掉

 第二個客戶端必須等待第一個客戶端完成工作，這樣服務端才能繼續向後執行；因爲我們這里的服務器程序同一時間隻能處理一個客戶端連接。我們這里對服務端程序做一點小改動，使其支持併發：在handleConn函數調用的地方增加go關鍵字，讓每一次handleConn的調用都進入一個獨立的goroutine。

+<u><i>gopl.io/ch8/clock2</i></u>
 ```go
-gopl.io/ch8/clock2
 for {
 	conn, err := listener.Accept()
 	if err != nil {
--- a/ch8/ch8-03.md
+++ b/ch8/ch8-03.md
@@ -11,8 +11,8 @@ func handleConn(c net.Conn) {

 一個更有意思的echo服務應該模擬一個實際的echo的“迴響”，併且一開始要用大寫HELLO來表示“聲音很大”，之後經過一小段延遲返迴一個有所緩和的Hello，然後一個全小寫字母的hello表示聲音漸漸變小直至消失，像下面這個版本的handleConn(譯註：笑看作者腦洞大開)：

+<u><i>gopl.io/ch8/reverb1</i></u>
 ```go
-gopl.io/ch8/reverb1
 func echo(c net.Conn, shout string, delay time.Duration) {
 	fmt.Fprintln(c, "\t", strings.ToUpper(shout))
 	time.Sleep(delay)
@@ -33,8 +33,8 @@ func handleConn(c net.Conn) {

 我們需要陞級我們的客戶端程序，這樣它就可以發送終端的輸入到服務器，併把服務端的返迴輸出到終端上，這使我們有了使用併發的另一個好機會：

+<u><i>gopl.io/ch8/netcat2</i></u>
 ```go
-gopl.io/ch8/netcat2
 func main() {
 	conn, err := net.Dial("tcp", "localhost:8000")
 	if err != nil {
@@ -74,8 +74,8 @@ $ killall reverb1

 註意客戶端的第三次shout在前一個shout處理完成之前一直沒有被處理，這貌似看起來不是特别“現實”。眞實世界里的迴響應該是會由三次shout的迴聲組合而成的。爲了模擬眞實世界的迴響，我們需要更多的goroutine來做這件事情。這樣我們就再一次地需要go這個關鍵詞了，這次我們用它來調用echo：

+<u><i>gopl.io/ch8/reverb2</i></u>
 ```go
-gopl.io/ch8/reverb2
 func handleConn(c net.Conn) {
 	input := bufio.NewScanner(c)
 	for input.Scan() {
--- a/ch8/ch8-04-1.md
+++ b/ch8/ch8-04-1.md
@@ -10,8 +10,8 @@

 在8.3節的客戶端程序，它在主goroutine中（譯註：就是執行main函數的goroutine）將標準輸入複製到server，因此當客戶端程序關閉標準輸入時，後台goroutine可能依然在工作。我們需要讓主goroutine等待後台goroutine完成工作後再退出，我們使用了一個channel來同步兩個goroutine：

+<u><i>gopl.io/ch8/netcat3</i></u>
 ```Go
-gopl.io/ch8/netcat3
 func main() {
 	conn, err := net.Dial("tcp", "localhost:8000")
 	if err != nil {
--- a/ch8/ch8-04-2.md
+++ b/ch8/ch8-04-2.md
@@ -6,9 +6,8 @@ Channels也可以用於將多個goroutine鏈接在一起，一個Channels的輸

 第一個goroutine是一個計數器，用於生成0、1、2、……形式的整數序列，然後通過channel將該整數序列發送給第二個goroutine；第二個goroutine是一個求平方的程序，對收到的每個整數求平方，然後將平方後的結果通過第二個channel發送給第三個goroutine；第三個goroutine是一個打印程序，打印收到的每個整數。爲了保持例子清晰，我們有意選擇了非常簡單的函數，當然三個goroutine的計算很簡單，在現實中確實沒有必要爲如此簡單的運算構建三個goroutine。

+<u><i>gopl.io/ch8/pipeline1</i></u>
 ```Go
-gopl.io/ch8/pipeline1
-
 func main() {
 	naturals := make(chan int)
 	squares := make(chan int)
@@ -65,9 +64,8 @@ go func() {

 在下面的改進中，我們的計數器goroutine隻生成100個含數字的序列，然後關閉naturals對應的channel，這將導致計算平方數的squarer對應的goroutine可以正常終止循環併關閉squares對應的channel。（在一個更複雜的程序中，可以通過defer語句關閉對應的channel。）最後，主goroutine也可以正常終止循環併退出程序。

+<u><i>gopl.io/ch8/pipeline2</i></u>
 ```Go
-gopl.io/ch8/pipeline2
-
 func main() {
 	naturals := make(chan int)
 	squares := make(chan int)
--- a/ch8/ch8-04-3.md
+++ b/ch8/ch8-04-3.md
@@ -18,8 +18,8 @@ func printer(in chan int)

 這是改進的版本，這一次參數使用了單方向channel類型：

+<u><i>gopl.io/ch8/pipeline3</i></u>
 ```Go
-gopl.io/ch8/pipeline3
 func counter(out chan<- int) {
 	for x := 0; x < 100; x++ {
 		out <- x
--- a/ch8/ch8-04-4.md
+++ b/ch8/ch8-04-4.md
@@ -2,7 +2,6 @@

 帶緩存的Channel內部持有一個元素隊列。隊列的最大容量是在調用make函數創建channel時通過第二個參數指定的。下面的語句創建了一個可以持有三個字符串元素的帶緩存Channel。圖8.2是ch變量對應的channel的圖形表示形式。

-
 ```Go
 ch = make(chan string, 3)
 ```
--- a/ch8/ch8-05.md
+++ b/ch8/ch8-05.md
@@ -2,9 +2,10 @@

 本節中，我們會探索一些用來在併行時循環迭代的常見併發模型。我們會探究從全尺寸圖片生成一些縮略圖的問題。gopl.io/ch8/thumbnail包提供了ImageFile函數來幫我們拉伸圖片。我們不會説明這個函數的實現，隻需要從gopl.io下載它。

+<u><i>gopl.io/ch8/thumbnail</i></u>
 ```go
-gopl.io/ch8/thumbnail
 package thumbnail
+
 // ImageFile reads an image from infile and writes
 // a thumbnail-size version of it in the same directory.
 // It returns the generated file name, e.g., "foo.thumb.jpg".
@@ -13,8 +14,8 @@ func ImageFile(infile string) (string, error)

 下面的程序會循環迭代一些圖片文件名，併爲每一張圖片生成一個縮略圖：

+<u><i>gopl.io/ch8/thumbnail</i></u>
 ```go
-gopl.io/ch8/thumbnail
 // makeThumbnails makes thumbnails of the specified files.
 func makeThumbnails(filenames []string) {
 	for _, f := range filenames {
@@ -61,7 +62,6 @@ func makeThumbnails3(filenames []string) {

 註意我們將f的值作爲一個顯式的變量傳給了函數，而不是在循環的閉包中聲明：

-
 ```go
 for _, f := range filenames {
 	go func() {
@@ -108,7 +108,6 @@ func makeThumbnails4(filenames []string) error {
 // makeThumbnails5 makes thumbnails for the specified files in parallel.
 // It returns the generated file names in an arbitrary order,
 // or an error if any step failed.
-
 func makeThumbnails5(filenames []string) (thumbfiles []string, err error) {
 	type item struct {
 		thumbfile string
@@ -167,7 +166,6 @@ func makeThumbnails6(filenames <-chan string) int64 {
 		close(sizes)
 	}()

-
 	var total int64
 	for size := range sizes {
 		total += size
--- a/ch8/ch8-06.md
+++ b/ch8/ch8-06.md
@@ -2,8 +2,8 @@

 在5.6節中，我們做了一個簡單的web爬蟲，用bfs(廣度優先)算法來抓取整個網站。在本節中，我們會讓這個這個爬蟲併行化，這樣每一個彼此獨立的抓取命令可以併行進行IO，最大化利用網絡資源。crawl函數和gopl.io/ch5/findlinks3中的是一樣的。

+<u><i>gopl.io/ch8/crawl1</i></u>
 ```go
-gopl.io/ch8/crawl1
 func crawl(url string) []string {
 	fmt.Println(url)
 	list, err := links.Extract(url)
@@ -52,8 +52,7 @@ https://golang.org/doc/
 https://golang.org/blog/
 ...
 2015/07/15 18:22:12 Get ...: dial tcp: lookup blog.golang.org: no such host
-2015/07/15 18:22:12 Get ...: dial tcp 23.21.222.120:443: socket:
-                                                    too many open files
+2015/07/15 18:22:12 Get ...: dial tcp 23.21.222.120:443: socket: too many open files
 ...
 ```

@@ -65,8 +64,8 @@ https://golang.org/blog/

 讓我們重寫crawl函數，將對links.Extract的調用操作用獲取、釋放token的操作包裹起來，來確保同一時間對其隻有20個調用。信號量數量和其能操作的IO資源數量應保持接近。

+<u><i>gopl.io/ch8/crawl2</i></u>
 ```go
-gopl.io/ch8/crawl2
 // tokens is a counting semaphore used to
 // enforce a limit of 20 concurrent requests.
 var tokens = make(chan struct{}, 20)
@@ -85,7 +84,6 @@ func crawl(url string) []string {

 第二個問題是這個程序永遠都不會終止，卽使它已經爬到了所有初始鏈接衍生出的鏈接。(當然，除非你慎重地選擇了合適的初始化URL或者已經實現了練習8.6中的深度限製，你應該還沒有意識到這個問題)。爲了使這個程序能夠終止，我們需要在worklist爲空或者沒有crawl的goroutine在運行時退出主循環。

-
 ```go
 func main() {
 	worklist := make(chan []string)
@@ -95,7 +93,6 @@ func main() {
 	n++
 	go func() { worklist <- os.Args[1:] }()

-
 	// Crawl the web concurrently.
 	seen := make(map[string]bool)

@@ -112,7 +109,6 @@ func main() {
 		}
 	}
 }
-
 ```

 這個版本中，計算器n對worklist的發送操作數量進行了限製。每一次我們發現有元素需要被發送到worklist時，我們都會對n進行++操作，在向worklist中發送初始的命令行參數之前，我們也進行過一次++操作。這里的操作++是在每啟動一個crawler的goroutine之前。主循環會在n減爲0時終止，這時候説明沒活可榦了。
--- a/ch8/ch8-07.md
+++ b/ch8/ch8-07.md
@@ -2,8 +2,8 @@

 下面的程序會進行火箭發射的倒計時。time.Tick函數返迴一個channel，程序會週期性地像一個節拍器一樣向這個channel發送事件。每一個事件的值是一個時間戳，不過更有意思的是其傳送方式。

+<u><i>gopl.io/ch8/countdown1</i></u>
 ```go
-gopl.io/ch8/countdown1
 func main() {
 	fmt.Println("Commencing countdown.")
 	tick := time.Tick(1 * time.Second)
@@ -17,8 +17,8 @@ func main() {

 現在我們讓這個程序支持在倒計時中，用戶按下return鍵時直接中斷發射流程。首先，我們啟動一個goroutine，這個goroutine會嚐試從標準輸入中調入一個單獨的byte併且，如果成功了，會向名爲abort的channel發送一個值。

+<u><i>gopl.io/ch8/countdown2</i></u>
 ```go
-gopl.io/ch8/countdown2
 abort := make(chan struct{})
 go func() {
 	os.Stdin.Read(make([]byte, 1)) // read a single byte
@@ -47,7 +47,6 @@ select會等待case中有能夠執行的case時去執行。當條件滿足時，

 讓我們迴到我們的火箭發射程序。time.After函數會立卽返迴一個channel，併起一個新的goroutine在經過特定的時間後向該channel發送一個獨立的值。下面的select語句會會一直等待到兩個事件中的一個到達，無論是abort事件或者一個10秒經過的事件。如果10秒經過了還沒有abort事件進入，那麽火箭就會發射。

-
 ```go
 func main() {
 	// ...create abort channel...
@@ -82,8 +81,8 @@ for i := 0; i < 10; i++ {

 下面讓我們的發射程序打印倒計時。這里的select語句會使每次循環迭代等待一秒來執行退出操作。

+<u><i>gopl.io/ch8/countdown3</i></u>
 ```go
-gopl.io/ch8/countdown3
 func main() {
 	// ...create abort channel...

--- a/ch8/ch8-08.md
+++ b/ch8/ch8-08.md
@@ -2,8 +2,8 @@

 在本小節中，我們會創建一個程序來生成指定目録的硬盤使用情況報告，這個程序和Unix里的du工具比較相似。大多數工作用下面這個walkDir函數來完成，這個函數使用dirents函數來枚舉一個目録下的所有入口。

+<u><i>gopl.io/ch8/du1</i></u>
 ```go
-gopl.io/ch8/du1
 // walkDir recursively walks the file tree rooted at dir
 // and sends the size of each found file on fileSizes.
 func walkDir(dir string, fileSizes chan<- int64) {
@@ -72,7 +72,6 @@ func main() {
 func printDiskUsage(nfiles, nbytes int64) {
 	fmt.Printf("%d files  %.1f GB\n", nfiles, float64(nbytes)/1e9)
 }
-
 ```

 這個程序會在打印其結果之前卡住很長時間。
@@ -87,8 +86,8 @@ $ ./du1 $HOME /usr /bin /etc

 下面這個du的變種會間歇打印內容，不過隻有在調用時提供了-v的flag才會顯示程序進度信息。在roots目録上循環的後台goroutine在這里保持不變。主goroutine現在使用了計時器來每500ms生成事件，然後用select語句來等待文件大小的消息來更新總大小數據，或者一個計時器的事件來打印當前的總大小數據。如果-v的flag在運行時沒有傳入的話，tick這個channel會保持爲nil，這樣在select里的case也就相當於被禁用了。

+<u><i>gopl.io/ch8/du2</i></u>
 ```go
-gopl.io/ch8/du2
 var verbose = flag.Bool("v", false, "show verbose progress messages")

 func main() {
@@ -116,6 +115,7 @@ loop:
 	printDiskUsage(nfiles, nbytes) // final totals
 }
 ```
+
 由於我們的程序不再使用range循環，第一個select的case必須顯式地判斷fileSizes的channel是不是已經被關閉了，這里可以用到channel接收的二值形式。如果channel已經被關閉了的話，程序會直接退出循環。這里的break語句用到了標籤break，這樣可以同時終結select和for兩個循環；如果沒有用標籤就break的話隻會退出內層的select循環，而外層的for循環會使之進入下一輪select循環。

 現在程序會悠閒地爲我們打印更新流：
@@ -133,8 +133,8 @@ $ ./du2 -v $HOME /usr /bin /etc

 然而這個程序還是會花上很長時間才會結束。無法對walkDir做併行化處理沒什麽别的原因，無非是因爲磁盤繫統併行限製。下面這個第三個版本的du，會對每一個walkDir的調用創建一個新的goroutine。它使用sync.WaitGroup (§8.5)來對仍舊活躍的walkDir調用進行計數，另一個goroutine會在計數器減爲零的時候將fileSizes這個channel關閉。

+<u><i>gopl.io/ch8/du3</i></u>
 ```go
-gopl.io/ch8/du3
 func main() {
 	// ...determine roots...
 	// Traverse each root of the file tree in parallel.
@@ -167,7 +167,6 @@ func walkDir(dir string, n *sync.WaitGroup, fileSizes chan<- int64) {

 由於這個程序在高峯期會創建成百上韆的goroutine，我們需要脩改dirents函數，用計數信號量來阻止他同時打開太多的文件，就像我們在8.7節中的併發爬蟲一樣：

-
 ```go
 // sema is a counting semaphore for limiting concurrency in dirents.
 var sema = make(chan struct{}, 20)
--- a/ch8/ch8-09.md
+++ b/ch8/ch8-09.md
@@ -10,8 +10,8 @@ Go語言併沒有提供在一個goroutine中終止另一個goroutine的方法，

 隻要一些小脩改，我們就可以把退出邏輯加入到前一節的du程序。首先，我們創建一個退出的channel，這個channel不會向其中發送任何值，但其所在的閉包內要寫明程序需要退出。我們同時還定義了一個工具函數，cancelled，這個函數在被調用的時候會輪詢退出狀態。

+<u><i>gopl.io/ch8/du4</i></u>
 ```go
-gopl.io/ch8/du4
 var done = make(chan struct{})

 func cancelled() bool {
--- a/ch8/ch8-10.md
+++ b/ch8/ch8-10.md
@@ -1,10 +1,11 @@
 ## 8.10. 示例: 聊天服務

 我們用一個聊天服務器來終結本章節的內容，這個程序可以讓一些用戶通過服務器向其它所有用戶廣播文本消息。這個程序中有四種goroutine。main和broadcaster各自是一個goroutine實例，每一個客戶端的連接都會有一個handleConn和clientWriter的goroutine。broadcaster是select用法的不錯的樣例，因爲它需要處理三種不同類型的消息。
+
 下面演示的main goroutine的工作，是listen和accept(譯註：網絡編程里的概念)從客戶端過來的連接。對每一個連接，程序都會建立一個新的handleConn的goroutine，就像我們在本章開頭的併發的echo服務器里所做的那樣。

+<u><i>gopl.io/ch8/chat</i></u>
 ```go
-gopl.io/ch8/chat
 func main() {
 	listener, err := net.Listen("tcp", "localhost:8000")
 	if err != nil {