lab golang study tutorials 03

Go tutorials

• 📔📝본 내용은 tour.golang.org 에 있는 내용을 정리한 글입니다.

Hello, Go world! 3

codeblocks

goroutines.go

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("goroutine0")
	say("main0") // 순차 실행끼리는 순서 맞춰서 실행됨
	say("main1") // goroutine 끼리는 독립적으로 비동기식으로 처리됨 ()

	go say("goroutine2") // 나중에 나오는 순차 실행과 함께 실행됨
	go say("goroutine1") // 여기서는 say("main2")

	say("main2")

}

output

main0
goroutine0
goroutine0
main0
main0
goroutine0
goroutine0
main0
main0
goroutine0
main1
main1
main1
main1
main1
goroutine1
main2
goroutine2
main2
goroutine1
goroutine2
goroutine1
main2
goroutine2
main2
goroutine1
goroutine2
goroutine1
main2

channels.go

package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
	x, y := <-c, <-c // receive from c // 아마 스택 개념?


	fmt.Printf("%T, %v \n",c,c)

	fmt.Println(x, y, x+y)
}

output

chan int, 0xc000100060 
-5 17 12

channels-reverse.go

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	go sum(s[len(s)/2:], c)
	go sum(s[:len(s)/2], c)

	x, y:= <-c, <-c // receive from c // 아마 channel은 스택 개념? 
	

	fmt.Printf("%T, %v \n",c,c)

	fmt.Println(x, y, x+y)
}

output-reverse

chan int, 0xc000062060 
17 -5 12

channel-test.go

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	for index, _ := range s {
		go sum(s[index:index+1],c)
	}
	for i := range c {
		fmt.Println(i)
	}
	
}

output-test

2
7
8
4
-9
0

[7]
[2]
[8]
[-9]
[4]
[0]
7
8
2
-9
0
4


0
-9
4
8
2
7


0
2
7
-9
8
4
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
	/tmp/sandbox710675921/prog.go:20 +0x193

channels-close-test-1.go

package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c

}
func closechan(c chan int, iter []int) {
	for index, _ := range iter {
		go sum(iter[index:index+1],c) // 여기가 다름!! 
	} 
	close(c)
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}
	
	c := make(chan int)
	go closechan(c,s)

	for i := range c {	
		fmt.Println(i)
	}
	/*
		go sum(s[:len(s)/2], c)
		go sum(s[len(s)/2:], c)
		x, y := <-c, <-c // receive from c

		fmt.Println(x, y, x+y)
	*/
}

output

/// goroutine 쓰면 아무것도 안뜬다!?

Program exited.

channels-close-test-1.go

package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c

}
func closechan(c chan int, iter []int) {
	for index, _ := range iter {
		sum(iter[index:index+1],c) // 여기가 다름!!
	} 
	close(c)
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}
	
	c := make(chan int)
	go closechan(c,s)

	for i := range c {	
		fmt.Println(i)
	}
	/*
		go sum(s[:len(s)/2], c)
		go sum(s[len(s)/2:], c)
		x, y := <-c, <-c // receive from c

		fmt.Println(x, y, x+y)
	*/
}

output

/// goroutine 안쓰면 뜬다!?

7
2
8
-9
4
0

느낀점: goroutine 을 쓰면, 다른 execution 이라고 보는게 맞을 것 같다.

참고: close(c) 없애고, goroutine 없으면 7 2 8 -9 4 0

있으면 0 8 7 2 -9 4

아래는 공통적으로 나오는 경고문

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
  /tmp/sandbox232678665/prog.go:26 +0x14c

test.go

/*
  both are possible! 
  
  c := make(chan int)
	go closechan(c,s)

  c := make(chan int, 10)
	closechan(c,s)
*/

package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c

}
func closechan(c chan int, iter []int) {
	for index, _ := range iter {
	 	sum(iter[index:index+1],c) // 여기가 다름!!
	} 
	close(c)
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}
	
	c := make(chan int)
	go closechan(c,s)

	for i := range c {	
		fmt.Println(i)
	}
	/*
		go sum(s[:len(s)/2], c)
		go sum(s[len(s)/2:], c)
		x, y := <-c, <-c // receive from c

		fmt.Println(x, y, x+y)
	*/
}

buffered-channels.go

package main

import "fmt"

func chanfunc(c chan int,integer int) {
	c <- integer
}

func main() {
	ch := make(chan int)
	
	go chanfunc(ch,1)	
	go chanfunc(ch,2)
	go chanfunc(ch,3)

	fmt.Println(<-ch)
	fmt.Println(<-ch)
  fmt.Println(<-ch)
}

no-buffered-channels-block.go

func main() {
	ch := make(chan int)
	go chanfunc(ch,1)	

	chanfunc(ch,2)	

	fmt.Println(<-ch)


}

no-buffered-channels-block-output

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.chanfunc(...)
	/tmp/sandbox977088187/prog.go:5
main.main()
	/tmp/sandbox977088187/prog.go:12 +0x87

goroutine 20 [chan send]:
main.chanfunc(0xc00009c060, 0x1)
	/tmp/sandbox977088187/prog.go:5 +0x3f
created by main.main
	/tmp/sandbox977088187/prog.go:10 +0x65


/// goroutine 없을때
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.chanfunc(...)
	/tmp/sandbox473627473/prog.go:5
main.main()
	/tmp/sandbox473627473/prog.go:11 +0x65


/// print 없을때
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.chanfunc(...)
	/tmp/sandbox473783957/prog.go:5
main.main()
	/tmp/sandbox473783957/prog.go:11 +0x57

range-and-close.go

package main

import (
	"fmt"
)

func fibonacci(n int, c chan int) {
	x, y := 0, 1
	for i := 0; i < n; i++ {
		c <- x
		x, y = y, x+y
	}
	close(c)
}

func main() {
	c := make(chan int, 10)
	go fibonacci(cap(c), c)
	// fibonacci(10, c) // capacity 주면 goroutine 안써도 값 들어감
  // go fibonacci(11, c) // goroutine 쓰면 capacity 초과해도 값 들어감

	for i := range c {
		fmt.Println(i," (i)")

		v, ok:= <-c
		
		fmt.Println(v,ok)
	}
	v, ok:= <-c
		
	fmt.Println("final check: ",v,ok)
	
}

range-and-close-output

0  (i)
1 true
1  (i)
2 true
3  (i)
5 true
8  (i)
13 true
21  (i)
34 true
final check:  0 false

channels-close-buffer-size-test.go

package main

import (
	"fmt"
	"time"
)

func fibonacci(n int, c chan int) {
	x, y := 0, 1
	for i := 0; i < n; i++ {
		c <- x
		x, y = y, x+y
	}
	fmt.Println("gogo")
	close(c)
}

func main() {
	c := make(chan int, 1)
	// go fibonacci(cap(c), c)
	// fibonacci(10, c) // capacity 주면 goroutine 안써도 값 들어감
    go fibonacci(10, c) // goroutine 쓰면 capacity 초과해도 값 들어감

	for i := range c {
		fmt.Println(i," (i)")
		time.Sleep(1000*time.Millisecond)

		
	}
	v, ok:= <-c
		
	fmt.Println("final check: ",v,ok)
	
}

output

0  (i)
1  (i)
1  (i)
2  (i)
3  (i)
5  (i)
8  (i)
13  (i)
21  (i)
gogo
34  (i)
final check:  0 false

select 부터 다시!