go修行12日目 channelなど

channel

package main

import "fmt"

// SlieceとChannelを扱う関数
func gorooutine1(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	// <- Channelに送信
	c <- sum
}

func main() {
	s := []int{1, 2, 3, 4, 5}
	// channel integerを扱う
	c := make(chan int)
	go gorooutine1(s, c)
	// <- c　でChannelから受け取るまで待機
	x := <-c
	fmt.Println(x)
}

15

キューのような使い方

• 2つのチャンネルを並列実行しても2つの処理の実行を待つ

package main

import "fmt"

// SlieceとChannelを扱う関数
func gorooutine1(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	// <- Channelに送信
	c <- sum
}

func gorooutine2(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	// <- Channelに送信
	c <- sum
}

func main() {
	s := []int{1, 2, 3, 4, 5}
	// channel integerを扱う
	c := make(chan int)
	go gorooutine1(s, c)
	go gorooutine2(s, c)
	// <- c　でChannelから受け取るまで待機
	x := <-c
	fmt.Println(x)
	y := <-c
	fmt.Println(y)
}

15
15

Bufferd channel

package main

import "fmt"

func main() {
	ch := make(chan int, 2)
	ch <- 100
	fmt.Println(len(ch))
	ch <- 200
	fmt.Println(len(ch))
	// rangeで呼び出す場合はcloseしないと次のChannelを呼ぼうとしてエラーになる
	close(ch)

	// forで1つづつ呼び出す
	for c := range ch {
		fmt.Println(c)
	}
}

1
2
100
200

channelのrange、Close

package main

import "fmt"

func goroutine1(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
		c <- sum
	}
	// 処理完了後はcloseを入れる
	close(c)
}

func main() {
	s := []int{1, 2, 3, 4, 5}
	c := make(chan int, len(s))
	go goroutine1(s, c)
	// channelを１回ずつ呼び出す
	for i := range c {
		fmt.Println(i)
	}
}

1
3
6
10
15

Producer Consumer

package main

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

func producer(ch chan int, i int) {
	// Something
	ch <- i * 2
}

func consumer(ch chan int, wg *sync.WaitGroup) {
	for i := range ch {
		func() {
			fmt.Println("process", i*1000)
			wg.Done()
		}()
	}
	fmt.Println("#################################")
}

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

	// Producer
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go producer(ch, i)
	}

	// Consumer
	go consumer(ch, &wg)
	wg.Wait()
	close(ch)
	time.Sleep(2 * time.Second)
	fmt.Println("Done")
}

process 0
process 4000
process 2000
process 6000
process 8000
process 10000
process 12000
process 14000
process 16000
process 18000
#################################
Done

fan-out fan-in

package main

import "fmt"

func producer(first chan int) {
	defer close(first)
	for i := 0; i < 10; i++ {
		first <- i
	}
}

func multi2(first chan int, second chan int) {
	defer close(second)
	for i := range first {
		// 1 * 2 = 2
		// 2 * 2 = 4
		second <- i * 2
	}
}

func multi4(second chan int, third chan int) {
	defer close(third)
	for i := range second {
		// 2 * 4 = 8
		// 4 * 4 = 4
		third <- i * 4
	}
}

func main() {

	first := make(chan int)
	second := make(chan int)
	third := make(chan int)

	go producer(first)
	go multi2(first, second)
	go multi4(second, third)
	for result := range third {
		fmt.Println(result)
	}
}

0
8
16
24
32
40
48
56
64
72

select

package main

import (
	"fmt"
	"time"
)

func goroutine1(ch chan string) {
	for {
		ch <- "packat from 1"
		time.Sleep(3 * time.Second)
	}
}

func goroutine2(ch chan string) {
	for {
		ch <- "packat from 2"
		time.Sleep(1 * time.Second)
	}
}

func main() {
	c1 := make(chan string)
	c2 := make(chan string)
	go goroutine1(c1)
	go goroutine2(c2)

	for {
		select {
		case msg1 := <-c1:
			fmt.Println(msg1)
		case msg2 := <-c2:
			fmt.Println(msg2)
		}
	}
}

packat from 1
packat from 2
packat from 2
packat from 2
packat from 1
packat from 2
packat from 2
packat from 2

Default Section

package main

import (
	"fmt"
	"time"
)

func main() {
	tick := time.Tick(100 * time.Millisecond)
	boom := time.After(500 * time.Millisecond)

	for {
		select {
		// 100Millisocond毎
		case <-tick:
			fmt.Println("tick,")
			// 500Millisocond毎
		case <-boom:
			fmt.Println("BOOM")
			// loop終了
			return
			// それ以外はピリオド
		default:
			fmt.Println("    .")
			time.Sleep(50 * time.Millisecond)
		}
	}
}

    .
    .
tick,
    .
    .
tick,
    .
    .
tick,
    .
    .
tick,
    .
    .
tick,
BOOM