Channel in Go

1
Private & Confidential
Channel in Go
Jaych Su - 3 Feb 2021

2
Private & Confidential 2
What is Channel
”
A channel provides a mechanism for
concurrently executing functions to
communicate by sending and receiving values
of a specified element type.
-- Golang Spec (//golang.org/ref/spec#Channel_types)

3
What behind Channel
QWhat will happen if read from/write to
a closed channel?

4
<- Closed Channel <-
What behind Channel
x, ok := <- chan
- [unread data] x is remaining value, ok is true
- [has been read] x is falsy value, ok is false
- [empty] x is falsy value, ok is false

5
What behind Channel
panic
x, ok := <- chan
chan <- x

6
type hchan struct {
// points to an array of
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
// lock protects all fields
in hchan
lock mutex
...
}
What behind Channel
https://github.com/golang/go/blob/master/src/runtime/chan.go#L32

7
What behind Channel
c := make(chan int, 4)
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}

8
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
buf (doubly circular linked list)
lock
11
12
13
14
goroutine
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}

9
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
lock
goroutine
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
11
12
13
14

10
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11
lock
goroutine buf (doubly circular linked list)
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
12
13
14

11
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
12
13
14

12
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
12
13
14

13
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11 12
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
13
14

14
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11 12
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
13
14

15
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11 12
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
13
14

16
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11 12
13
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14

17
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11 12
13
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14

18
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
11 12
13
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14

19
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c
close(c)
<- c
<- c
c <- 14
12
13
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11

20
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c
close(c)
<- c
<- c
c <- 14
12
13
lock
sendx
recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11

21
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c
close(c)
<- c
<- c
c <- 14
12
13
sendx
recvx
lock
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11

22
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c // 12
close(c)
<- c
<- c
c <- 14
13
lock
sendx recvx
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11
12

23
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c // 12
close(c)
<- c
<- c
c <- 14
13
sendx recvx
lock
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11
12

24
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c // 12
close(c)
<- c // 13
<- c
c <- 14
sendx
recvx
lock
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11
12
13

25
What behind Channel
c <- 11
c <- 12
c <- 13
<- c // 11
<- c // 12
close(c)
<- c // 13
<- c // 0
c <- 14
sendx
recvx
lock
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}
14
11
12
13

26
What behind Channel
c <- 11
c <- 12
c <- 13
<- c
<- c
close(c)
<- c
<- c
c <- 14
panic: send on closed channel
sendx
recvx
lock
type hchan struct {
dataqsiz elements
buf unsafe.Pointer
// send index
sendx uint
// receive index
recvx uint
in hchan
lock mutex
...
}

27
chan <- x
What behind Channel
panic
x, ok := <- chan

28
What behind Channel
”
Do not communicate by sharing memory;
instead, share memory by communicating.
-- Someone else
memory
goroutine
goroutine
goroutine
memory memory

29
What behind Channel
”
-- Someone else
memory
goroutine
goroutine
goroutine
memory memory

30
What behind Channel
”
-- Someone else
memory
goroutine
goroutine
goroutine
memory memory

31
What behind Channel
”
-- Someone else
memory
goroutine
goroutine
goroutine
memory memory

32
What crashes Channel
QWhat crashes Channel?

33
QWhat crashes Channel?
What if buf is full?

34
type hchan struct {
// list of send waiters
sendq waitq
// list of recv waiters
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
sendx
recvx
11 12
14 13

35
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
sendx
recvx
11 12
14 13
sendq
recvq

36
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
scheduling
sendx
recvx
11 12
14 13
sendq
recvq

37
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
scheduling
sendx
recvx
11 12
14 13
sendq
recvq
c <- 15
goroutine

38
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
scheduling
sendx
recvx
11 12
14 13
sendq
recvq
c <- 15
goroutine

39
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
scheduling
sendx
recvx
11 12
14 13
sendq
recvq
c <- 15
goroutine
<- c
goroutine

40
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
scheduling
sendx
recvx
11 12
14 13
sendq
recvq
c <- 15
goroutine
<- c
goroutine

41
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
lock
scheduling
recvx
sendx
12
14 13
sendq
recvq
c <- 15
goroutine
<- c
// 11
goroutine

42
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
12
14 13
sendq
recvq
c <- 15
goroutine
<- c
// 11
goroutine
lock
recvx
sendx

43
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
12
14 13
sendq
recvq
c <- 15
goroutine
lock
recvx
sendx

44
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
12
14 13
sendq
recvq
c <- 15
goroutine
lock
recvx
sendx

45
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
12
14 13
sendq
recvq
c <- 15
goroutine
lock
recvx
sendx

46
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
sendx
recvx
15 12
14 13
sendq
recvq
goroutine
lock

47
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
15 12
14 13
sendq
recvq
goroutine
lock
sendx
recvx

48
type hchan struct {
sendq waitq
recvq waitq
buf unsafe.Pointer
sendx uint
recvx uint
lock mutex
...
}
scheduling
15 12
14 13
sendq
recvq
lock
sendx
recvx

49
1. communication between goroutine
2. multiplexing
3. timeout handling
4. range channel
5. read-only/write-only channel
When uses Channel

50
func main() {
var c chan int
go func() {
c <- 1
}()
<-c
}
2. multiplexing
3. timeout handling
4. range channel
When uses Channel

51
for {
select {
case x, ok := <-c1:
...
case x, ok := <-c2:
...
default:
...
}
}
2. multiplexing
3. timeout handling
4. range channel
When uses Channel

52
select {
case <- c:
// get from channel c
case <- time.After(2 * time.Second)
// timeout when getting from channel c
}
When uses Channel
2. multiplexing
3. timeout handling
4. range channel

53
2. multiplexing
3. timeout handling
4. range channel
When uses Channel
func consumer(c chan int) {
for x := range c {
...
}
}
func producer(c chan int) {
for _, x := range values {
c <- x
}
}

54
// usually used for declaration
func foo(ch chan<- int) <-chan int {
...
}
When uses Channel
2. multiplexing
3. timeout handling
4. range channel

55
# [val, pre, nxt]
dummy = []
dummy[:] = [None, dummy, dummy]
[PLUS] Something interesting

56
# [val, pre, nxt]
dummy = []
node1 = [1, None, None]
node1[1] = node1[2] = dummy
dummy[1] = dummy[2] = node1
node2[1] = node1
node2[2] = node1[2]
node1[2][1] = node2
node1[2] = node2

57
# [val, pre, nxt]
dummy = []
node2[1] = node1
node2[2] = node1[2]
node1[2][1] = node2
node1[2] = node2
doubly circular linked list

58
# [val, pre, nxt]
dummy = []
node2[1] = node1
node2[2] = node1[2]
node1[2][1] = node2
node1[2] = node2
D

59
# [val, pre, nxt]
dummy = []
node2[1] = node1
node2[2] = node1[2]
node1[2][1] = node2
node1[2] = node2
1
D

60
# [val, pre, nxt]
dummy = []
node2[1] = node1
node2[2] = node1[2]
node1[2][1] = node2
node1[2] = node2
2
1
D

61
1. What is Channel
2. What behind Channel
3. What crashes Channel
4. When uses Channel
5. [PLUS] Something interesting

62
1. What is Channel

63
1. What is Channel

64
1. What is Channel

65
1. What is Channel

66
Thank you!

Channel in Go

More Related Content

What's hot (20)

Similar to Channel in Go (20)

Recently uploaded (20)

Channel in Go