import asyncio
import time


async def say_after(delay: int, what: str) -> None:
    await asyncio.sleep(delay)
    print(what)


async def main():
    # 合計で約4秒かかる
    # sleep(2) → hello出力 → sleep(2) → world出力
    print(f"started at {time.strftime('%X')}")

    await say_after(2, 'hello')
    await say_after(2, 'world')

    print(f"finished at {time.strftime('%X')}")


if __name__ == '__main__':
    asyncio.run(main())

import asyncio
import time


async def say_after(delay: int, what: str) -> None:
    await asyncio.sleep(delay)
    print(what)


async def main():
    # 約2秒ちょっとで動く(早くなった！)
    # asyncio.create_task() で「コルーチン」を並行にスケジュールしているから
    task1 = asyncio.create_task(say_after(2, 'hello'))
    task2 = asyncio.create_task(say_after(2, 'world'))

    print(f"started at {time.strftime('%X')}")

    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")


if __name__ == '__main__':
    asyncio.run(main())

package main

import "fmt"

func main() {
	fmt.Println("mainゴルーチンはじまるよ〜")

	go sayHello()

	fmt.Println("mainゴルーチンおわるよ〜")
}

func sayHello() {
	fmt.Println("ゴルーチン2")
}

package main

import (
	"fmt"
	"sync"
)

// p.40 2つのゴルーチンの間に合流ポイントを作った例
func main() {
	fmt.Println("mainゴルーチンすたーと")
	var wg sync.WaitGroup

	wg.Add(1)

	sayHello := func() {
		fmt.Println("hello")
		wg.Done()
	}

	go sayHello()
	wg.Wait()

	fmt.Println("mainゴルーチンおわり〜")
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	salutation := "hello" // salutationは「あいさつ」とか「敬礼」とかって意味らしい

	wg.Add(1)
	go func() {
		defer wg.Done()
		salutation = "welcome"
		fmt.Println(salutation, &salutation)
	}()

	wg.Wait()
	fmt.Println(salutation, &salutation)
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup

	for _, salutation := range []string{"hello", "greetings", "good day"} {
		wg.Add(1)

		go func() {
			defer wg.Done()
			fmt.Println(salutation)
		}()
	}
	
	wg.Wait()
}

$ go run ch3/3.1/4/main.go
good day
good day
good day

# 順不同に hello greetings good day が出力されそうな気がするが、こうはならない
$ go run ch3/3.1/4/main.go
greetings
hello 
good day

package main

import (
	"fmt"
	"sync"
)

func main() {
    var wg  sync.WaitGroup

	for _, salutation := range []string{"hello", "greeting", "good day"} {
		wg.Add(1)

		go func(salutation string){
			fmt.Println(salutation)
			wg.Done()
		}(salutation)
	}

	wg.Wait()
}

package main

func main() {
	ch := make(chan int)

	// ずーっと受信を待つゴルーチン
	go func() {
		<-ch
	}()
}

[root@a16aa2563528 /]# taskset -c 0 perf bench sched pipe -T
# Running 'sched/pipe' benchmark:
# Executed 1000000 pipe operations between two threads

     Total time: 3.833 [sec]

       3.833102 usecs/op
         260885 ops/sec

$ go test -bench=. -cpu=1 ch3/3.1/8/context_switch_test.go 
goos: darwin
goarch: amd64
cpu: VirtualApple @ 2.50GHz
BenchmarkContextSwitch   9939310               120.1 ns/op
PASS
ok      command-line-arguments  1.771s

docker run --rm -it centos:centos7 bash

yum update -y
yum install -y perf

package main

import (
	"sync"
	"testing"
)

func BenchmarkContextSwitch(b *testing.B) {
	var wg sync.WaitGroup
	begin := make(chan struct{})
	c := make(chan struct{})

	var token struct{}
	sender := func() {
		defer wg.Done()
		<-begin
		for i := 0; i < b.N; i++ {
			c <- token
		}
	}

	receiver := func() {
		defer wg.Done()
		<-begin
		for i := 0; i < b.N; i++ {
			<-c
		}
	}

	wg.Add(2)
	go sender()
	go receiver()

	b.StartTimer()
	close(begin)
	wg.Wait()
}

$ go doc sync.WaitGroup     
package sync // import "sync"

type WaitGroup struct {
        // Has unexported fields.
}
    A WaitGroup waits for a collection of goroutines to finish. The main
    goroutine calls Add to set the number of goroutines to wait for. Then each
    of the goroutines runs and calls Done when finished. At the same time, Wait
    can be used to block until all goroutines have finished.

    A WaitGroup must not be copied after first use.

func (wg *WaitGroup) Add(delta int)
func (wg *WaitGroup) Done()
func (wg *WaitGroup) Wait()

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("1st goroutine sleeping...")
		time.Sleep(1 * time.Second)
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("2nd goroutine sleeping...")
		time.Sleep(2*time.Second)
	}()

	wg.Wait()
	fmt.Println("All goroutine complete")
}

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup

	go func() {
		wg.Add(1) // Addの呼び出しをゴルーチン内部でやってしまっている！ → 競合状態！
		defer wg.Done()
		fmt.Println("1st goroutine sleeping...")
		time.Sleep(1 * time.Second)
	}()

	go func() {
		wg.Add(1) // Addの呼び出しをゴルーチン内部でやってしまっている！ → 競合状態！
		defer wg.Done()
		fmt.Println("2nd goroutine sleeping...")
		time.Sleep(2*time.Second)
	}()

	wg.Wait()
	fmt.Println("All goroutine complete")
}

# 1st と 2ndの出力がないまま終了してしまっている！
# Add(1) される前に、Wait()呼ばれた場合こうなる
# なんにもAddしてないなら、Wait()は素通りだよね
$ go run main.go
All goroutine complete

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Wait()
	fmt.Println("All goroutine complete")
}

$ go doc sync.Mutex
package sync // import "sync"

type Mutex struct {
        // Has unexported fields.
}
    A Mutex is a mutual exclusion lock.
    The zero value for a Mutex is an unlocked mutex.

    A Mutex must not be copied after first use.

func (m *Mutex) Lock()
func (m *Mutex) Unlock()

$ go doc sync.Locker
package sync // import "sync"

type Locker interface {
        Lock()
        Unlock()
}
    A Locker represents an object that can be locked and unlocked.

package main

import (
	"sync"
)

// sync.Mutex をコピーする
// コンパイルは通るが、警告がでる
func main() {
	var m1 sync.Mutex
	var m2 sync.Mutex
	m2 = m1 // assignment copies lock value to m2: sync.Mutex
	_ = m2 // assignment copies lock value to _: sync.Mutex
}

$ go build main.go # Buildはできる

# go vet で検査すると...
$ go vet main.go 
# command-line-arguments
3.2.4/5/main.go:11:7: assignment copies lock value to m2: sync.Mutex
3.2.4/5/main.go:12:6: assignment copies lock value to _: sync.Mutex

$ go doc strings.Builder
package strings // import "strings"

type Builder struct {
	// Has unexported fields.
}
    A Builder is used to efficiently build a string using Write methods. It
    minimizes memory copying. The zero value is ready to use. Do not copy a
    non-zero Builder.

$ go doc sync.Once
package sync // import "sync"

type Once struct {
        // Has unexported fields.
}
    Once is an object that will perform exactly one action.

    A Once must not be copied after first use.

func (o *Once) Do(f func())

package main

import (
	"fmt"
	"sync"
)

// https://pkg.go.dev/sync#Once
func main() {
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}

	// 単一チャネルで管理
	// 『Go言語による並行処理』では sync.WaitGroup 使ってた
	done := make(chan bool)

	for i := 0; i < 10; i++ {
		go func() {
			once.Do(onceBody)
			done <- true
		}()
	}

	for i := 0; i < 10; i++ {
		<-done
	}
}

// Once is an object that will perform exactly one action.
type Once struct {
	m    Mutex
	done uint32
}

func (o *Once) Do(f func()) {
	// 1. `Once.done`が1なら、即returnで関数fは呼ばれない
	// o.done == 1 をアトミックにしただけ
	if atomic.LoadUint32(&o.done) == 1 {
		return
	}
	// Slow-path.

	// 2. ロックをとる
	o.m.Lock()

	// 3. 終わったらロックを解除
	defer o.m.Unlock()

	// 4. ここで、doneかどうかを確認する
	// この時点でロックをとっている == 1つのゴルーチンしかこないので、
	// `o.done==0`は、`sync/atomic`を使わない比較でOKっぽい
	if o.done == 0 {
		// 5. deferにしているので、panicしたとしても実行したことになる
		// もし関数をfを実行したときにpanicが起きても、doneの値は1に設定される
		// つまり、このOnceインスタンスは、もう関数は実行しない
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

$ go env GOVERSION                               
go1.16

$ grep -ir sync.Once $(go env GOROOT)/src | wc -l
     128

package main

import (
	"fmt"
	"sync"
)

func main() {
	var count int

	increment := func() { count++ }
	decrement := func() { count-- }

	var once sync.Once
	once.Do(increment)
	once.Do(decrement)

	fmt.Println(count)
}

// uint32 Xadd(uint32 volatile *val, int32 delta)
// Atomically:
//	*val += delta;
//	return *val;
TEXT runtime∕internal∕atomic·Xadd(SB), NOSPLIT, $0-20
	MOVQ	ptr+0(FP), BX
	MOVL	delta+8(FP), AX
	MOVL	AX, CX
	LOCK
	XADDL	AX, 0(BX)
	ADDL	CX, AX
	MOVL	AX, ret+16(FP)
	RET

package main

import (
	"fmt"
	"net/http"
	"sync/atomic"
	"time"
)

func main() {
	var (
		count1 int
		count2 int32
	)
	
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		x := count1 + 1
		time.Sleep(30 * time.Millisecond)
		count1 = x
		count2 = atomic.AddInt32(&count2, 1)
		
		fmt.Fprintln(w, count1, count2)
	})

	http.ListenAndServe(":8080", nil)
}

package main

import "fmt"

func main() {
	stringStream := make(chan string)

	go func() {
		stringStream <- "Hello channels!"
	}()

	fmt.Println(<-stringStream)
}

package main

import "fmt"

func main() {
	stringStream := make(chan string)

	// fatal error: all goroutines are asleep - deadlock!
	stringStream <- "Hello channels!"

	fmt.Println(<-stringStream)
}

package main

func main() {
	sendOnlyChannel := make(chan<- int)
	receiveOnlyChanel := make(<-chan int)

	// invalid operation: <-sendOnlyChannel (receive from send-only type chan<- int)
	<-sendOnlyChannel // 受信しようとしてみる

	// invalid operation: receiveOnlyChanel <- 1 (send to receive-only type <-chan int)
	receiveOnlyChanel <- 1 // 送信しようとしてみる
}

package main

import "fmt"

func main() {
	ch := make(chan string)

	go func() {
		// 無名ゴルーチンは、キャパシティが空くまで待機する
		// キャパシティがあれば、チャネルに書き込む
		ch <- "Hello channels!"
	}()

	// メインゴルーチンは、読み込みをする
	// もし、チャネルが空だったら、メインゴルーチンは待機する
	// つまり、チャネルにデータが書き込まれるまで、メインゴルーチンは待機する
	// だから、プログラムは終了しないし、実行結果が「決定的」になる
	fmt.Println(<-ch)
}

$ go run main.go
無名ゴルーチン（っ'-')╮ =͟͟͞(1) : データ書き込んだよ！
Mainゴルーチン ∠( ﾟдﾟ)／: (1) を受け取ったぞ
Mainゴルーチン ∠( ﾟдﾟ)／: 次、送って良いぞ〜
------------------------------
無名ゴルーチン（っ'-')╮ =͟͟͞(2) : データ書き込んだよ！
Mainゴルーチン ∠( ﾟдﾟ)／: (2) を受け取ったぞ
Mainゴルーチン ∠( ﾟдﾟ)／: 次、送って良いぞ〜
------------------------------
無名ゴルーチン（っ'-')╮ =͟͟͞(3) : データ書き込んだよ！
Mainゴルーチン ∠( ﾟдﾟ)／: (3) を受け取ったぞ
Mainゴルーチン ∠( ﾟдﾟ)／: 次、送って良いぞ〜
------------------------------
無名ゴルーチン（っ'-')╮ =͟͟͞(4) : データ書き込んだよ！
Mainゴルーチン ∠( ﾟдﾟ)／: (4) を受け取ったぞ
Mainゴルーチン ∠( ﾟдﾟ)／: 次、送って良いぞ〜
------------------------------
無名ゴルーチン（っ'-')╮ =͟͟͞(5) : データ書き込んだよ！
Mainゴルーチン ∠( ﾟдﾟ)／: (5) を受け取ったぞ
Mainゴルーチン ∠( ﾟдﾟ)／: 次、送って良いぞ〜
------------------------------
おしまい

package main

import (
	"fmt"
	"strings"
	"time"
)

// ゴルーチン間のコミュニケーション感を演出してみる
// Mainゴルーチン と 無名ゴルーチン にアイコンを付ける → ∠( ﾟдﾟ)／  っ'-')╮
// 発言させてみる。sleepをつけると会話っぽくなる
func main() {
	ch := make(chan int)

	go func() {
		defer close(ch) // 無名ゴルーチンでforループの処理が終わったら、チャネルを閉じる

		for i := 1; i <= 5; i++ {
			ch <- i
			fmt.Printf("無名ゴルーチン（っ'-')╮ =͟͟͞(%d) : データ書き込んだよ！\n", i)
		}
	}()

	for integer := range ch {
		time.Sleep(1 * time.Second)

		fmt.Printf("Mainゴルーチン ∠( ﾟдﾟ)／: (%d) を受け取ったぞ\n", integer)
		time.Sleep(1 * time.Second)

		fmt.Printf("Mainゴルーチン ∠( ﾟдﾟ)／: 次、送って良いぞ〜\n")
		time.Sleep(1 * time.Second)
		fmt.Println(strings.Repeat("-", 30))
	}

	fmt.Println("おしまい")
}

package main

import "fmt"

func main() {
	ch := make(chan int)

	go func() {
		defer close(ch)
		for i := 0; i < 10; i++ {
			ch <- i
		}
	}()

	// for-rangeっていうよりも「終了条件のない」繰り返し
	// 終了の判定は close(ch) をきっかけにforが勝手にやってくれる感じ
	for v := range ch {
		fmt.Println(v)
	}
}

package main

import "fmt"

func main() {
	ch := make(chan int)

	go func() {
		for i := 0; i <= 5; i++ {
			ch <- i
		}
	}()

	for v := range ch {
		fmt.Println(v)
	}
}

$ go run main.go 
0
1
2
3
4
5
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	begin := make(chan int)
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1)

		go func(n int) {
			defer wg.Done()
			fmt.Printf("\t（っ'-')╮ =͞ ゴルーチン%d号 待機...\n", n)

			// 狼煙がくるまで、各ゴルーチンは待機
			// beginチャネルがcloseされるまで(受信可能になるまで)待機
			// close(begin)されたあとなら、無限に受信ができる(そして、ゼロ値を返す)
			<-begin

			fmt.Printf("\t（っ'-')╮ =͞ ゴルーチン%d号 出動！\n", n)
		}(i)
	}

	// ゴルーチン間のコミュニケーションをイメージしやすくするための仕込み
	fmt.Println("∠( ﾟдﾟ)／: 狼煙の準備なう...")
	time.Sleep(1 * time.Second)
	fmt.Println("∠( ﾟдﾟ)／: 狼煙だ〜〜〜")
	time.Sleep(1 * time.Second)

	close(begin) // 終了の狼煙を上げる

	wg.Wait() // 無名ゴルーチンたちが終了するまで、Mainゴルーチンは待機

	fmt.Println("∠( ﾟдﾟ)／: おしまい")
}

$ go run main.go
∠( ﾟдﾟ)／: 狼煙の準備なう...
        （っ'-')╮ =͞ ゴルーチン5号 待機...
        （っ'-')╮ =͞ ゴルーチン1号 待機...
        （っ'-')╮ =͞ ゴルーチン2号 待機...
        （っ'-')╮ =͞ ゴルーチン3号 待機...
        （っ'-')╮ =͞ ゴルーチン4号 待機...
∠( ﾟдﾟ)／: 狼煙だ〜〜〜
        （っ'-')╮ =͞ ゴルーチン3号 出動！
        （っ'-')╮ =͞ ゴルーチン4号 出動！
        （っ'-')╮ =͞ ゴルーチン1号 出動！
        （っ'-')╮ =͞ ゴルーチン2号 出動！
        （っ'-')╮ =͞ ゴルーチン5号 出動！
∠( ﾟдﾟ)／: おしまい

package main

func main() {
	ch := make(chan rune)
	ch<-'A' // fatal error: all goroutines are asleep - deadlock!
}

package main

func main() {
	ch := make(chan rune, 0) // 明示的に第2引数に0を渡す
	ch <- 'A' // fatal error: all goroutines are asleep - deadlock!
}

package main

import "fmt"

func main() {
	ch := make(chan rune, 1) // バッファサイズが1
	ch <- 'A'
	fmt.Println(<-ch) // 65
}

// これはわかりやすい
func main() {
	ch := make(chan rune, 1)
	fmt.Println(<-ch) // fatal error: all goroutines are asleep - deadlock!
}

package main

import (
	"bytes"
	"fmt"
	"os"
)

func main() {
	var stdoutBuff bytes.Buffer
	defer stdoutBuff.WriteTo(os.Stdout)

	ch := make(chan int, 4) // バッファサイズ: 4

	go func() {
		defer close(ch)
		defer fmt.Fprintln(&stdoutBuff, "Producer Done.")

		// バッファサイズ分だけ整数を送信する(事前にわかっている)
		for i := 0; i < 5; i++ {
			fmt.Fprintf(&stdoutBuff, "っ'-')╮ =͞  Sending: %d\n", i)
			ch <- i
		}
	}()

	for integer := range ch {
		fmt.Fprintf(&stdoutBuff, "∠( ﾟдﾟ)／ Received %v.\n", integer)
	}
}

$ go run main.go
っ'-')╮ =͞  Sending: 0
っ'-')╮ =͞  Sending: 1
っ'-')╮ =͞  Sending: 2
っ'-')╮ =͞  Sending: 3
っ'-')╮ =͞  Sending: 4
Producer Done.
∠( ﾟдﾟ)／ Received 0.
∠( ﾟдﾟ)／ Received 1.
∠( ﾟдﾟ)／ Received 2.
∠( ﾟдﾟ)／ Received 3.
∠( ﾟдﾟ)／ Received 4.

package main

import "fmt"

func main() {
	// chanOwner は intChチャネル の所有権を持っている
	// で、「非所有者」が使えるように、「読み込み専用チャネル」を返している
	chanOwner := func() <-chan int {
		// チャネルの所有者なので、チャネルを初期化している(定義1)
		intCh := make(chan int, 5)

		go func() {
			// チャネルの所有者なので、チャネルを閉じている(定義3)
			defer close(intCh)

			for i := 0; i <= 5; i++ {
				// チャネルの所有者なので、チャネルに書き込んでいる(定義2)
				intCh <- i
			}
		}()

		return intCh
	}

	// チャネルの所有者が、消費者にむけて「読み込んでよいぞチャネル」を作ってあげた感じ
	// このへん擬人法の怪しさがあふれる
	ch := chanOwner()

	// Mainゴルーチンは、チャネルの非所有者(チャネルを読み込むだけの人)
	for result:= range ch {
		fmt.Printf("Received: %d\n", result)
	}

	fmt.Printf("Done receiving!")
}

package main

func receiveOnlyChannel() <-chan int {
	c := make(chan int) // この時点では読み書きできるチャネル

	return c
}

func main() {
	// 返り値の型のおかげで受信専用のチャネルになっている
	// 呼び出し側が書き込むことを制限できている感じ
	ch := receiveOnlyChannel()

	// 許されていない行為(書き込み)をしようとしてもできなくなっている(嬉しい)
	ch <- 1 // invalid operation: c <- 1 (send to receive-only type <-chan int)
}

package main

// 双方向 => 受信専用 は OK
func to1(c chan int) <-chan int {
	return c
}

// 双方向 => 送信専用 は OK
func to2(c chan int) chan<- int {
	return c
}

// 一方向 => 双方向 は無理
// cannot use c (type <-chan int) as type chan int in return argument
func to3(c <-chan int) chan int {
	return c
}

// 一方向 => 双方向 は無理
// cannot use c (type chan<- int) as type chan int in return argument
func to4(c chan<- int) chan int {
	return c
}

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Now()

	c := make(chan interface{})

	go func() {
		fmt.Printf("（っ'-')╮ =͞  5秒寝まーす\n")
		time.Sleep(5 * time.Second)
		fmt.Printf("（っ'-')╮ =͞  close!!!\n")
		close(c)
	}()

	fmt.Println("∠( ﾟдﾟ)／ 読み込みを待機...")

	// ホントは <-c だけで十分(selectなくてもいける)けど、記述を拡張していくためにわざと書いている
	select {
	// チャネルに読み込み可能になる(書き込まれるか、closeされるか)まで、チャネルはブロックする
	// つまり、Mainゴルーチンが待機するってこと
	case <-c:
		fmt.Printf("∠( ﾟдﾟ)／ %v経ちましたとさ\n", time.Since(start))
	}
}

package main

import "fmt"

// 疑問1: 複数のチャネルが準備OKな場合、selectはどうなるのか？
func main() {
	c1 := make(chan interface{})
	c2 := make(chan interface{})

	// 速攻で、closeしている！ == チャネルが読み込める状態 == 準備OK状態
	close(c1)
	close(c2)

	var count1, count2 int

	for i := 1000; i > 0; i-- {
		select {
		case <-c1:
			count1++
		case <-c2:
			count2++
		}
	}

	// Q. 何が出力されるでしょう？
	fmt.Printf("count1: %d\ncount2: %d\n", count1, count2)
}

$ go run 3/main.go
count1: 517
count2: 483

$ go run 3/main.go
count1: 496
count2: 504

$ go run 3/main.go
count1: 507
count2: 493

package main

import (
	"fmt"
	"time"
)

func main() {
	var c chan int

	select {
	case <-c: // nilチャネルなので永遠にブロック
	case <-time.After(5 * time.Second): // time.Afterは読み込み専用チャネルを返している
		fmt.Println("Timed out")
	}
}

package main

import (
	"fmt"
	"time"
)

// 疑問: チャネルが1つも読み込めず、その間に何かする必要がある場合にはどうしたらいいの？
func main() {
	start := time.Now()
	var c1, c2 <-chan int // どちらもnilチャネルなので永遠ブロック

	select {
	case <-c1:
	case <-c2:
	default:
		fmt.Printf("In default after%v\n\n", time.Since(start))
	}
}

package main

import (
	"fmt"
	"time"
)

// defaultをfor-selectループで使う
// ゴルーチンの結果報告を待つ間に、他のゴルーチンで仕事を進められる！
func main() {

	done := make(chan interface{})
	go func() {
		fmt.Printf("（っ'-')╮ =͞  仕事するぞ！\n")
		time.Sleep(5 * time.Second)
		fmt.Printf("（っ'-')╮ =͞  仕事おわり！\n")
		close(done)
	}()

	fmt.Printf("∠( ﾟдﾟ)／ 他のゴルーチン（っ'-')╮ の仕事が終わるまで数を数えまくるぞい\n")
	var counter int
loop:
	for {

		select {
		case <-done:
			break loop
		default:
			// <-doneができない == doneチャネルが読み込めない(closeされていない)なら何もしない
			// つまり、Mainゴルーチンはcounterをインクリメントする仕事をする
			// 1つ仕事(インクリメント)しては、チェックする感じになる
		}
		counter++
		time.Sleep(100 * time.Millisecond)
	}

	fmt.Printf("∠( ﾟдﾟ)／ %d回数えたで！\n", counter)
}

$ go run main.go
∠( ﾟдﾟ)／ 他のゴルーチン（っ'-')╮ の仕事が終わるまで数を数えまくるぞい
（っ'-')╮ =͞  仕事するぞ！
（っ'-')╮ =͞  仕事おわり！
∠( ﾟдﾟ)／ 48回数えたで！

package main

func main() {
	// fatal error: all goroutines are asleep - deadlock!
	//
	// goroutine 1 [select (no cases)]:
	select {}
}

package main

import "fmt"

func main() {
	data := make([]int, 4) // こいつが拘束対象の囚人か？

	// やろうと思えば、独房の外で囚人を操作できてしまう！
	// 規約違反！
	// data[3] = 333
	// data[4] = 444

	loopData := func(handleData chan<- int) {
		// loopData という独房
		// ここにdataという囚人を拘束する規約になっている ← アドホック！
		defer close(handleData)

		// 独房内で囚人を操作できる(これは独房内だから規約に準じている)
		for i := range data {
			handleData <- data[i]
		}
	}

	handleData := make(chan int)
	go loopData(handleData)

	for num := range handleData {
		fmt.Println(num)
	}
}

package main

import "fmt"

func main() {
	// 読み込み専用チャネルを返す時点で、所有者は「他の連中(ゴルーチン)には読み込みしか許可しないぞ！」って意思表示してる感じ
	chanOwner := func() <-chan int {
		// resultsをこの関数のレキシカルスコープ内で初期化している
		// → 操作できるのはこの関数(独房)の中だけ
		// → 書き込み権限の「拘束」ってわけ
		results := make(chan int, 5) // 今回の囚人

		go func() {
			// 所定の書き込みが終わったらclose(他の人は書き込めない)
			// まさに、チャネルの所有者の行いですな
			defer close(results)

			for i := 0; i <= 5; i++ {
				results <- i
			}
		}()

		return results
	}

	// 拘束を突破しようとしても....
	// 独房の外からは、囚人に書き込みができない！(嬉しい)
	// results <- 999 // コンパイルエラー！

	consumer := func(results <-chan int) {
		// resultsの読み込み権限"だけ"のコピーを受け取っている

		// 拘束を突破しようとしても....
		// results <- 999 // コンパイルエラー！(嬉しい)

		// 約束通りの読み込み作業
		for result := range results {
			fmt.Printf("Received %d\n", result)
		}
		fmt.Println("Done receiving!")
	}

	results := chanOwner()
	consumer(results)
}

package main

import (
	"bytes"
	"fmt"
	"sync"
)

func main() {
	printData := func(wg *sync.WaitGroup, data []byte) {
		// printData宣言以前にdataが宣言されてないので
		// コピーを受け取るしかない
		// printDataを起動するゴルーチンがどう渡すかに制限されるわけ
		defer wg.Done()

		var buf bytes.Buffer
		for _, b:= range data {
			fmt.Fprintf(&buf, "%c", b)
		}

		fmt.Println(buf.String())
	}

	var wg sync.WaitGroup
	wg.Add(2)

	data := []byte("golang")

	// printDataが使えるdataを一部の範囲に絞っている == 拘束
	go printData(&wg, data[:3]) // 先頭3バイトだけ操作できる拘束
	go printData(&wg, data[3:]) // 後半3バイトだけ操作できる拘束

	wg.Wait()
}

package main

import (
	"bytes"
	"fmt"
	"sync"
)

func main() {
	// printData以前に宣言するとやりたい放題で大変！
	data := []byte("golang")
	var buf bytes.Buffer

	printData := func(wg *sync.WaitGroup, data []byte) {
		defer wg.Done()

		for _, b := range data {
			fmt.Fprintf(&buf, "%c", b)
		}

		fmt.Println(buf.String())
	}

	var wg sync.WaitGroup
	wg.Add(2)

	go printData(&wg, data[:3])
	go printData(&wg, data[3:])

	wg.Wait()
}

package main

import (
	"fmt"
)

// p.93 簡単なゴルーチンリークの例
func main() {
	doWork := func(strings chan string) <-chan interface{} {
		completed := make(chan interface{})

		// ゴルーチン1号: （っ'-')╮
		go func() {
			// ゴルーチン1号が終了したのなら、このdeferが実行されるはず
			defer fmt.Println("（っ'-')╮ =͟͟͞(終了) ﾌﾞｫﾝ")
			defer close(completed)

			for s := range strings {
				fmt.Println(s)
			}
		}()

		return completed
	}

	// Mainゴルーチンでは、nilチャネル を渡しているので、stringsには絶対書き込みは起きない
	// => ゴルーチン1号はメモリ内の残り続ける(このプロセスが生きている限り)
	doWork(nil)

	fmt.Println("Mainゴルーチン おわり.")
}

# ゴルーチン1号は終了していない！(deferで設定した終了メッセージがでてないから)
$ go run 1/main.go
Mainゴルーチン おわり.

package main

import (
	"fmt"
	"runtime"
	"time"
)

// p.93 ゴルーチンの親子間で親から子にキャンセルの信号を送れるようにする
// 親ゴルーチンがキャンセルしたいときに、キャンセルする
func main() {
	doWork := func(done <-chan interface{}, strings <-chan string) <-chan interface{} {
		terminated := make(chan interface{})

		// ゴルーチン1号
		go func() {
			// ゴルーチン1号が終了したのなら、このdeferが実行されるはず
			defer fmt.Println("（っ'-')╮ =͟͟͞(終了) ﾌﾞｫﾝ")
			defer close(terminated)

			for {
				select {

				case s := <-strings:
					fmt.Println(s)
				case <-done: // 親からキャンセルが来た場合は、returnする
					return
				}
			}
		}()
		return terminated
	}

	done := make(chan interface{})

	// nilチャネルを渡しているけど、ちゃんとゴルーチンは終了する！
	terminated := doWork(done, nil)

	// ゴルーチン2号
	go func() {
		// 1秒後に操作をキャンセルする
		time.Sleep(1 * time.Second)
		fmt.Println("∠( ﾟдﾟ)／: Canceling doWork(ゴルーチン1号)")
		close(done)
	}()

	fmt.Printf("ゴルーチンの数: %d\n", runtime.NumGoroutine()) // 3

	<-terminated // ゴルーチン1号が終了されるまでブロック

	fmt.Printf("ゴルーチンの数: %d\n", runtime.NumGoroutine()) // 1

	fmt.Println("Mainゴルーチン おわり.")
}

$ go run main.go
∠( ﾟдﾟ)／: Canceling doWork(ゴルーチン1号)
（っ'-')╮ =͟͟͞(終了) ﾌﾞｫﾝ
ゴルーチンの数: 1
Mainゴルーチン おわり.

package main

import (
	"fmt"
	"math/rand"
)

// p.94 ゴルーチンリーク
// ゴルーチンがチャネルに対して書き込みを行おうとしてブロックしている状況
func main() {
	newRanStream := func() <-chan int {
		randStream := make(chan int)

		go func() {
			defer fmt.Println("newRandomStream closure exited.")
			defer close(randStream)

			for {
				// 終了条件がないので、ずーっと書き込みを頑張り続ける
				randStream <- rand.Int()
			}
		}()

		return randStream
	}

	randStream := newRanStream()
	fmt.Println("3 random ints:")

	for i := 1; i <= 3; i++ {
		fmt.Printf("%d: %d\n", i, <-randStream)
	}
}

$ go run main.go
3 random ints:
1: 5577006791947779410
2: 8674665223082153551
3: 6129484611666145821

package main

import (
	"fmt"
	"math/rand"
	"runtime"
	"time"
)

func main() {
	newRandStream := func(done <-chan interface{}) <-chan int {
		randStream := make(chan int)

		go func() {
			defer fmt.Println("newRandStream closure exited.")
			defer close(randStream) // ところで、closeするのは所有者の責任だよね

			for {
				select {
				case randStream <- rand.Int():
				case <-done:
					return
				}
			}
		}()

		return randStream
	}

	done := make(chan interface{})
	randStream := newRandStream(done)

	fmt.Println("3 random ints:")
	for i := 1; i <= 3; i++ {
		fmt.Printf("%d: %d\n", i, <-randStream)
	}
	fmt.Printf("ゴルーチンの数: %d\n", runtime.NumGoroutine())

	// doneチャネルの所有者はMainゴルーチン
	// なので、責任を持ってcloseする
	close(done)

	// ゴルーチンのdeferの処理を待つためのSleep
	time.Sleep(1 * time.Second)

	fmt.Printf("ゴルーチンの数: %d\n", runtime.NumGoroutine())
}

$ go run main.go
3 random ints:
1: 5577006791947779410
2: 8674665223082153551
3: 6129484611666145821
ゴルーチンの数: 2
newRandStream closure exited.
ゴルーチンの数: 1

package main

import (
	"fmt"
	"net/http"
	"runtime"
)

// $ for i in {1..10}; do curl "localhost:8080"; done
func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		ch := make(chan int)

		go func() {
			ch <- 456
		}()
		go func() {
			ch <- 123
		}()

		<-ch

		fmt.Fprintf(w, "NumGoroutine: %d\n", runtime.NumGoroutine())
	})

	http.ListenAndServe(":8080", nil)
}

$ go run main.go

$ for i in {1..10}; do curl "localhost:8080"; done
NumGoroutine: 4
NumGoroutine: 5
NumGoroutine: 6
NumGoroutine: 7
NumGoroutine: 8
NumGoroutine: 9
NumGoroutine: 10
NumGoroutine: 11
NumGoroutine: 12
NumGoroutine: 13

package main

import (
	"fmt"
	"net/http"
	"runtime"
	"time"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		ch := make(chan int)

		// selectを使っているので、ゴルーチンはちゃんと終了する
		go func() {
			select {
			case ch <- 123:
			default:
			}
		}()

		go func() {
			select {
			case ch <- 123:
			default:
			}
		}()

		// 少しsleepして、2つのゴルーチンがdefaultで終わるようにする
		time.Sleep(100 * time.Millisecond)

		<-ch

		fmt.Fprintf(w, "NumGoroutine: %d\n", runtime.NumGoroutine())
	})

	http.ListenAndServe(":8080", nil)
}

$ go run 6/main.go

$ curl localhost:8080
# ずーっと終わらない

package main

import (
	"fmt"
	"log"
	"net/http"
)

type Result struct {
	Err      error
	Response *http.Response
	Url      string
}

func (r *Result) String() string {
	return fmt.Sprintf("%s: %s", r.Url, r.Response.Status)
}

func main() {
	urls := []string{
		"https://example.com",
		"https://python.org",
		"https://google.com",
		"https://badhost",
	}

	newResults := func(urls []string) <-chan Result {
		results := make(chan Result)

		for _, url := range urls {
			go func(url string) {
				resp, err := http.Get(url)
				result := Result{
					Err:      err,
					Response: resp,
					Url:      url,
				}

				// 素直に送信しているが...
				results <- result

			}(url)
		}

		return results
	}

	results := newResults(urls)

	// 本当に終了条件のないfor文になってしまっている
	for result := range results {
		if result.Err != nil {
			log.Println(result.Err)
			continue
		}

		fmt.Println(result.String())
	}

}

$ go run ch4/4.3/7/main.go 
2021/07/23 13:13:40 Get "https://badhost": dial tcp: lookup badhost: no such host
https://google.com: 200 OK
https://example.com: 200 OK
https://python.org: 200 OK

# このままずーっと終わらない

package main

import (
	"fmt"
	"log"
	"net/http"
	"runtime"
)

type Result struct {
	Err      error
	Response *http.Response
	Url      string
}

func (r *Result) String() string {
	return fmt.Sprintf("%s: %s", r.Url, r.Response.Status)
}

func main() {
	urls := []string{
		"https://example.com",
		"https://python.org",
		"https://google.com",
		"https://badhost",
	}

	done := make(chan interface{})
	defer close(done)
	defer fmt.Printf("ゴルーチン数: %d\n",runtime.NumGoroutine())

	newResponses := func(done <-chan interface{}, urls []string) <-chan Result {
		results := make(chan Result)

		for _, url := range urls {
			go func(url string) {
				resp, err := http.Get(url)
				result := Result{
					Err:      err,
					Response: resp,
					Url:      url,
				}
				select {
				// selectを仕込んでちゃんとゴルーチンを終了できるようにしておく
				case <-done:
					return
				case results <- result:
				}
			}(url)
		}

		return results
	}

	results := newResponses(done, urls)

	for i := 0; i < len(urls); i++ {
		result := <-results

		if result.Err != nil {
			log.Println(result.Err)
			continue
		}

		fmt.Println(result.String())
	}
	fmt.Printf("ゴルーチン数: %d\n",runtime.NumGoroutine())

}

$ go run main.go
2021/07/23 13:12:11 Get "https://badhost": dial tcp: lookup badhost: no such host
https://google.com: 200 OK
https://example.com: 200 OK
https://python.org: 200 OK
ゴルーチン数: 6
ゴルーチン数: 1

package main

import (
	"fmt"
	"net/http"
)

func main() {
	checkStatus := func(
		done <-chan interface{},
		urls ...string,
	) <-chan *http.Response {
		responses := make(chan *http.Response)

		go func() {
			defer close(responses)

			for _, url := range urls {
				resp, err := http.Get(url)
				if err != nil {
					// ① このゴルーチンができるのはエラーを出力するところまで！
					// 「親Goroutineに、エラーを返して、親が処理する」みたいなことができない！
					// エラーを返せないので、**誰かが処理してくれることを願うことしかできない**
					fmt.Println(err)
					continue
				}

				select {
				case <-done:
					return
				case responses <- resp:
				}
			}

		}()

		return responses
	}

	done := make(chan interface{})
	defer close(done)

	urls := []string{
		"https://www.google.com",
		"xxx",
		"https://badhost",
		"yyy",
		"https://example.com",
	}

	for response := range checkStatus(done, urls...) {
		fmt.Printf("Response: %v\n", response.Status)
	}
}

$ go run 1/main.go
Response: 200 OK
Get "xxx": unsupported protocol scheme ""
Get "https://badhost": dial tcp: lookup badhost: no such host
Get "yyy": unsupported protocol scheme ""
Response: 200 OK

package main

import (
	"fmt"
	"net/http"
)

type Result struct {
	Error    error
	Response *http.Response
}

func main() {
	checkStatus := func(
		done <-chan interface{},
		urls ...string,
	) <-chan Result {
		results := make(chan Result)

		go func() {
			defer close(results)

			for _, url := range urls {
				resp, err := http.Get(url)

				// if err != nil のチェックは、ゴルーチン内でやらない！
				result := Result{
					Error:    err,
					Response: resp,
				}

				select {
				case <-done:
					return
				case results <- result:
				}
			}
		}()

		return results
	}

	done := make(chan interface{})
	defer close(done)

	urls := []string{
		"https://www.google.com",
		"xxx",
		"https://badhost",
		"yyy",
		"https://example.com",
	}

	for result := range checkStatus(done, urls...) {
		// ゴルーチンの中(相対的に"小さな"コンテキスト)で起きたエラーを
		// "大きな"コンテキストで扱えている！
		if result.Error != nil {
			fmt.Printf("Error: %v\n", result.Error)
			continue
		}

		fmt.Printf("Response: %v\n", result.Response.Status)
	}

}

$ go run 2/main.go
Response: 200 OK
Error: Get "xxx": unsupported protocol scheme ""
Error: Get "https://badhost": dial tcp: lookup badhost: no such host
Error: Get "yyy": unsupported protocol scheme ""
Response: 200 OK

package main

import (
	"fmt"
	"net/http"
)

type Result struct {
	Err      error
	Response *http.Response
}

// p.101 3つ以上のエラーが発生したら処理を停止する
func main() {
	checkStatus := func(done chan interface{}, urls ...string) <-chan Result {
		results := make(chan Result)

		go func() {
			defer close(results)

			for _, url := range urls {
				resp, err := http.Get(url)
				result := Result{
					Err:      err,
					Response: resp,
				}

				select {
				case <-done:
					return
				case results <- result:
				}
			}
		}()

		return results
	}

	done := make(chan interface{})
	defer close(done)

	urls := []string{
		"https://www.google.com",
		"xxx",
		"https://badhost",
		"yyy",
		"https://example.com",
	}

	errCount := 0
	for result := range checkStatus(done, urls...) {
		if result.Err != nil {
			errCount++
			fmt.Printf("Err: %v\n", result.Err)

			if errCount >= 3 {
				fmt.Println("Too many errors, breaking!")
				break
			}
			continue
		}

		fmt.Printf("Response: %v\n", result.Response.Status)
	}

}

$ go run 3/main.go
Response: 200 OK
Err: Get "xxx": unsupported protocol scheme ""
Err: Get "https://badhost": dial tcp: lookup badhost: no such host
Err: Get "yyy": unsupported protocol scheme ""
Too many errors, breaking!

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	ctxParent, cancelParent := context.WithCancel(context.Background())

	timeLimit := 1 * time.Second
	ctxChild, cancelChild := context.WithTimeout(ctxParent, timeLimit)
	defer cancelChild()

	go func() {
		// cancelParent() を timeLimit より先に実行されるようにする
		time.Sleep(500 * time.Millisecond)
		cancelParent()
		fmt.Println("親コンテキストでキャンセル！")
	}()

	// ctxChild.Done() がブロック解除されるパターンは2つ
	// 1. cancelParent() が Timeoutの timeLimit が「来る前」に実行された場合
	// 2. cancelParent() が Timeoutの timeLimit が「来た後」に実行された場合
	<-ctxChild.Done()

	// どちらも同じ値になる!
	// 親コンテキスト(WithCancel)がキャンセルされたので、
	// 子コンテキスト(WithTimeout)もキャンセルされる
	fmt.Printf("ctxParent.Err() = %v\n", ctxParent.Err()) //  context canceled
	fmt.Printf("ctxChild.Err() = %v\n", ctxChild.Err())   //  context canceled

	fmt.Println("----- main() done ------")
}

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	ctxParent, cancelParent := context.WithCancel(context.Background())

	timeLimit := 1 * time.Second
	ctxChild, cancelChild := context.WithTimeout(ctxParent, timeLimit)
	defer cancelChild()

	go func() {
		// cancelParent() を timeLimit より後に実行されるようにする
		time.Sleep(3 * time.Second)
		cancelParent()
		fmt.Println("親コンテキストでキャンセル！")
	}()

	// ctxChild.Done() がブロック解除されるパターンは2つ
	// 1. cancelParent() が Timeoutの timeLimit が「来る前」に実行された場合
	// 2. cancelParent() が Timeoutの timeLimit が「来た後」に実行された場合
	<-ctxChild.Done()

	fmt.Printf("ctxParent.Err() = %v\n", ctxParent.Err()) // <nil>
	fmt.Printf("ctxChild.Err() = %v\n", ctxChild.Err())   // context deadline exceeded

	fmt.Println("----- main() done ------")
}