package main

import (
	"fmt"
	"os"
	"strconv"
	"time"
)

func main() {
	go func() {
		d, _ := strconv.Atoi(os.Args[2])
		time.Sleep(time.Second * time.Duration(d))
		fmt.Println("child", d)
	}()
	d, _ := strconv.Atoi(os.Args[1])
	time.Sleep(time.Second * time.Duration(d))
	fmt.Println("parent", d)
}

package main

import (
	"fmt"
	"time"
)

var a = 100

func main() {
	b := 200
	go func() {
		fmt.Printf("a:%d (%p) b:%d (%p) in child\n", a, &a, b, &b)
		a += 1
		b += 1

		go func() {
			fmt.Printf("a:%d (%p) b:%d (%p) in grandchild\n", a, &a, b, &b)
			a += 2
			b += 2
		}()
	}()
	time.Sleep(time.Second * 1)
	fmt.Printf("a:%d (%p) b:%d (%p) in parent\n", a, &a, b, &b)
}

package main

import (
	"fmt"
	"time"
)

func sum(receiver chan int, nums ...int) {
	total := 0
	for _, num := range nums {
		time.Sleep(1 * time.Second)
		total += num
	}
	receiver <- total
}

func product(receiver chan int, sender chan []int) {
	// 6秒待ってからチャネルからレシーブする
	time.Sleep(6 * time.Second)
	total := 1
	for _, num := range <-sender {
		total *= num
	}
	receiver <- total
}

func main() {
	receiver1 := make(chan int)
	receiver2 := make(chan int)
	receiver3 := make(chan int)
	receiver4 := make(chan int)
	sender := make(chan []int)

	go sum(receiver1, 1, 2, 3, 4)
	go sum(receiver2, 5, 6, 7, 8, 9)
	go sum(receiver3, 10, 11)
	go product(receiver4, sender)

	numbers := make([]int, 0)

	for n := 5; n > 0; {
		select {
		case total := <-receiver1:
			fmt.Println("sum1:", total)
			numbers = append(numbers, total)
			n--
		case total := <-receiver2:
			fmt.Println("sum2:", total)
			numbers = append(numbers, total)
			n--
		case total := <-receiver3:
			fmt.Println("sum3:", total)
			numbers = append(numbers, total)
			n--
		case sender <- numbers:
			n--
		case total := <-receiver4:
			fmt.Println("product:", total)
			n--
		}
	}
}

package main

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

func main() {
	ctx := context.Background()
	// ctx をベースに aCtx を作り、a に 1 をもたせる
	aCtx := context.WithValue(ctx, "a", 1)
	go func(ctx context.Context) {
		go func(ctx context.Context) {
			fmt.Println("a1:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(ctx)

		// aCtx をベースに aCtx2 を作り、 a に 2 をもたせる
		aCtx2 := context.WithValue(ctx, "a", 2)
		go func(ctx context.Context) {
			fmt.Println("a2:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(aCtx2)

		// aCtx2 をベースに aCtx3 を作り、 a に 3 をもたせる
		aCtx3 := context.WithValue(aCtx2, "a", 3)
		go func(ctx context.Context) {
			fmt.Println("a3:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(aCtx3)
	}(aCtx)

	// aCtx をベースに bCtx を作り b に 10 をもたせる
	bCtx := context.WithValue(aCtx, "b", 10)
	go func(ctx context.Context) {
		go func(ctx context.Context) {
			fmt.Println("b1:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(ctx)

		// bCtx をベースに bCtx2 を作り b に 20 をもたせる
		bCtx2 := context.WithValue(ctx, "b", 20)
		go func(ctx context.Context) {
			fmt.Println("b2:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(bCtx2)

		// bCtx2 をベースに bCtx3 を作り b に 30 をもたせる
		bCtx3 := context.WithValue(bCtx2, "b", 30)
		// bCtx2 をベースに bCtx4 を作り b に 40 をもたせる
		bCtx4 := context.WithValue(bCtx2, "b", 40)
		go func(ctx context.Context) {
			fmt.Println("b3:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(bCtx3)
		go func(ctx context.Context) {
			fmt.Println("b4:", ctx.Value("a"), ctx.Value("b"), &ctx)
		}(bCtx4)
	}(bCtx)
	time.Sleep(1 * time.Second)
}

package main

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

func gor1(ctx context.Context) {
	<-ctx.Done()
	fmt.Println("gor1 done")
}

func gor2(ctx context.Context) {
	<-ctx.Done()
	fmt.Println("gor2 done")
}

func main() {
	fmt.Println("started")
	defer fmt.Println("finished")
	ctx := context.Background()
	ctx, cancel := context.WithCancel(ctx)

	go gor1(ctx)
	go gor2(ctx)
	time.Sleep(1 * time.Second)
	cancel()
	time.Sleep(1 * time.Second)
}

package main

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

func main() {
	ctx0 := context.Background()

	go func() {
		ctx1, cancel1 := context.WithCancel(ctx0)
		cancel1()
		go func() {
			ctx1a := context.WithValue(ctx1, "a", 1)
			go func() {
				<-ctx1a.Done()
				fmt.Println("1a finished")
			}()
			<-ctx1.Done()
			fmt.Println("1 finished")
		}()

		ctx2, _ := context.WithCancel(ctx0)
		go func() {
			<-ctx2.Done()
			fmt.Println("2 finished")
		}()

		go func() {
			<-ctx0.Done()
			fmt.Println("3 finished")
		}()
	}()

	time.Sleep(1 * time.Second)
}