[쉽고 빠르게 끝내는 GO언어 프로그래밍 핵심 기초 입문 과정] Section 9 : Go 병행처리

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package main

import (
    "fmt"
    "time"
)

func exe1() {
    fmt.Println("exe1 func start", time.Now())
    time.Sleep(1 * time.Second) // 1초
    fmt.Println("exe1 func end", time.Now())
}

func exe2() {
    fmt.Println("exe2 func start", time.Now())
    time.Sleep(1 * time.Second) // 1초
    fmt.Println("exe2 func end", time.Now())
}

func exe3() {
    fmt.Println("exe3 func start", time.Now())
    time.Sleep(1 * time.Second) // 1초
    fmt.Println("exe3 func end", time.Now())
}

// 고루틴(Goroutine) 기초
func main() {
    exe1() // 가장 먼저 실행 (일반적인 실행 흐름)
    // exe2()
    // exe3()
    
    fmt.Println("Main Routine Start", time.Now())
    // 별도의 실행 흐름을 생성
    go exe2()
    go exe3()
    time.Sleep(4 * time.Second)
    fmt.Println("Main Routine End", time.Now())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import (
	"fmt"
	"time"
)

func exe(name string) {
    fmt.Println(name, "Start : ", time.Now())
    for i := 0; i < 1000; i++ {
        fmt.Println(name, ">>>>>", i)
    }
    fmt.Println(name, "End : ", time.Now())
}

func main() {
    // 고루틴 (Goroutine)
    exe("t1")
    
    fmt.Println("Main Routine Start : ", time.Now())
    go exe("t2")
    go exe("t3")
    
    time.Sleep(4 * time.Second) // time.Second, Minute, Hour, Millisecond ...
    fmt.Println("Main Routine End : ", time.Now())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

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

func exe(name int) {
    r := rand.Intn(100)
    fmt.Println(name, "Start : ", time.Now())
    for i := 0; i < 100; i++ {
        fmt.Println(name, ">>>>>>>", r, i)
    }
    fmt.Println(name, "End : ", time.Now())
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU()) // 현 시스템 cpu 코어 개수 반환 후 설정
    fmt.Println("Current System CPU : ", runtime.GOMAXPROCS(0)) // 설정 값 출력
    
    // Example 1
    fmt.Println("Main Routine Start : ", time.Now())
    for i := 0; i < 100; i++ {
        go exe(i) // GO ROUTINE 100개 생성
    }
    
    time.Sleep(5 * time.Second)
    fmt.Println("Main Routine End : ", time.Now())
}

1
2
3
4
5

for i := 0; i < 1000; i++ {
    go func() {
        fmt.Println("Closure Test => ", i)
    }()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

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

func main() {
    runtime.GOMAXPROCS(1)
    s := "Go Routine Closure : "
    
    for i := 0; i < 1000; i++ {
        go func(n int) {
            fmt.Println(s, n, " - ", time.Now())
        }(i)
    }
    time.Sleep(5 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

import "fmt"

func rangeSum(rg int, c chan int) {
  sum := 0
  for i := 1; i <= rg; i++ {
      sum += i
  }
  c <- sum
}

func main() {
  // 채널(Channel)
  c := make(chan int)
  
  go rangeSum(1000, c)
  go rangeSum(7000, c)
  go rangeSum(5000, c)
  
  result1 := <- c
  result2 := <- c
  result3 := <- c
  
  fmt.Println("Example 1 : ", result1)
  fmt.Println("Example 2 : ", result2)
  fmt.Println("Example 3 : ", result3)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import (
	"fmt"
	"time"
)

func main() {
  // Channel
  // 동기 : 버퍼 미사용
  ch := make(chan bool)
  cnt := 6
  
  go func() {
      for i := 0; i < cnt; i++ {
          ch <- true
          fmt.Println("Go => ", i)
          time.Sleep(1 * time.Second)
      }
  }()
  
  for i := 0; i < cnt; i++ {
      <- ch
      fmt.Println("Main : ", i)
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
	"fmt"
	"runtime"
)

func main() {
  runtime.GOMAXPROCS(1)
  ch  := make(chan bool, 2)
  cnt := 12
  
  go func() {
      for i := 0; i < cnt; i++ {
          ch <- true
          fmt.Println("Go => ", i)
      }
  }()
  
  for i := 0; i < cnt; i++ {
      <- ch
      fmt.Println("Main : ", i)
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main
 
import "fmt"
 
func main() {
  ch := make(chan int, 1)
  
  //수신자가 없더라도 보낼 수 있다.
  ch <- 101
  
  fmt.Println(<-ch)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
  ch := make(chan bool)
  go func() {
      for i := 0; i < 5; i++ {
          ch <- true
      }
      close(ch) // 5회 채널에 값 전송 후 채널 닫기
  }()
  
  for i := range ch { // 채널에서 값을 꺼내 온다
      fmt.Println("Example 1 : ", i)
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

ch := make(chan int)

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

if val1, ok := <- ch; ok {
	// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import (
  "fmt"
  "time"
)

// 발신 전용
func sendOnly(c chan<- int, cnt int) {
  for i := 0; i < cnt; i++ {
    c <- i
  }
  c <- 777
  // fmt.Println(<-c) // 수신 전용채널에서 발신 처리 시 예외 발생
}

// 수신 전용
func receiveOnly(c <-chan int) {
    for i := range c {
        fmt.Println("Received i : ", i)
    }
    fmt.Println(<-c)
}

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

    go sendOnly(c, 10) // 발신 전용
    go receiveOnly(c) // 수신 전용

    time.Sleep(1 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

// 수신 전용 채널을 리턴값으로 리턴
func sum(cnt int) <-chan int {
  sum := 0
  tot := make(chan int)
  
  go func() {
      for i := 1; i <= cnt; i++ {
          sum += i
      }
      tot <- sum
  }()
  return tot
}

func main() {
  c := sum(100)
  fmt.Println("Example 1 ",  <-c )
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package main

import "fmt"

func receiveOnly(cnt int) <-chan int {
	sum := 0
	tot := make(chan int)
	go func() {
		for i := 1; i <= cnt; i++ {
			sum += i
		}
		tot <- sum
		tot <- 777
		tot <- 777
		close(tot)
	}()
	return tot
}

func total(c <-chan int) <-chan int {
	tot := make(chan int)
	go func() {
		a := 0
		for i := range c {
			a = a + i
		}
		tot <- a
		close(tot)
	}()
	return tot
}

func main() {
	// Channel

	// Example1
	c := receiveOnly(100) // 채널 반환
	output := total(c) // 채널 전달 후 반환

	fmt.Println("Example 1 : ", <-output)

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan int)
	ch2 := make(chan string)

	go func() {
		for {
			ch1 <- 77
			time.Sleep(250 * time.Millisecond)
		}
	}()

	go func() {
		for {
			ch2 <- "Golang Hi!"
			time.Sleep(500 * time.Millisecond)
		}
	}()

	go func() {
		for {
			select {
			case num := <- ch1:
				fmt.Println("Channel 1 => ", num)
			case str := <- ch2:
				fmt.Println("Channel 2 => ", str)
			// default:
				// fmt.Println("Default Test !")
			}
		}
	}()

	time.Sleep(7 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package main

import (
	"fmt"
	"runtime"
)

// 구조체 선언 - 여러 Go Routine 에서 접근하는 공유 데이터
type count struct {
	num int
}

func (c *count) increment() {
	c.num += 1
}

func (c *count) result() {
	fmt.Println(c.num)
}

func main() {
	// 동기화 사용하지 않은 경우 예제
	// 시스템 전체 CPU 사용
	runtime.GOMAXPROCS(runtime.NumCPU())

	c := count{num: 0}
	done := make(chan bool)

	for i := 1; i <= 10000; i++ {
		go func() {
			c.increment()
			done <- true
			runtime.Gosched() // 다른 CPU 에게 양보
		}()
	}

	for i := 1; i <= 10000; i++ {
		<- done
	}

	c.result()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package main

import (
	"fmt"
	"runtime"
	"sync"
)

// 구조체 선언 - 여러 Go Routine 에서 접근하는 공유 데이터
type count struct {
	num int
	mutex sync.Mutex	// 구조체 내부에 있기때문에
}

// 공유 데이터가 변경이 되는 부분
func (c *count) increment() {
	// 공유 데이터 수정 전 뮤텍스로 보호
	c.mutex.Lock()
	c.num += 1
	// 공유 데이터 수정 후 보호 해제
	c.mutex.Unlock()
}

func (c *count) result() {
	fmt.Println(c.num)
}

func main() {
	// 동기화 사용한 예제
	// 시스템 전체 CPU 사용
	runtime.GOMAXPROCS(runtime.NumCPU())
	// runtime.GOMAXPROCS(1)

	c := count{num: 0}
	done := make(chan bool)

	for i := 1; i <= 10000; i++ {
		go func() {
			c.increment()
			done <- true
			runtime.Gosched() // 다른 CPU 에게 양보
		}()
	}

	for i := 1; i <= 10000; i++ {
		<- done
	}

	c.result()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package main

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

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())

	data := 0

	go func() {
		for i := 1; i <= 10; i++ {
			data += 1
			fmt.Println("Write : ", data)
			time.Sleep(200 * time.Millisecond)
		}
	}()

	go func() {
		for i := 1; i <= 10; i++ {
			fmt.Println("Read 1 : ", data)
			time.Sleep(1 * time.Second)
		}
	}()

	go func() {
		for i := 1; i <= 10; i++ {
			fmt.Println("Read 2 : ", data)
			time.Sleep(1 * time.Second)
		}
	}()

	time.Sleep(5 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package main

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

func main() {
	// 시스템 전체 cpu 사용
	runtime.GOMAXPROCS(runtime.NumCPU())

	data := 0
	mutex := new(sync.RWMutex) // var mutex = new (sync.RWMutex)

	go func() {
		for i := 1; i <= 10; i++ {
			// 쓰기 뮤텍스 잠금
			mutex.Lock()
			data += 1
			fmt.Println("Write : ", data)
			time.Sleep(200 * time.Millisecond)
			// 쓰기 뮤텍스 잠금 해제
			mutex.Unlock()
		}
	}()

	go func() {
		for i := 1; i <= 10; i++ {
			// 읽기 뮤텍스 잠금
			mutex.RLock()
			fmt.Println("Read 1 : ", data)
			time.Sleep(1 * time.Second)
			mutex.RUnlock()
			// 읽기 뮤텍스 해제
		}
	}()

	go func() {
		for i := 1; i <= 10; i++ {
			// 읽기 뮤텍스 잠금
			mutex.RLock()
			fmt.Println("Read 2 : ", data)
			time.Sleep(1 * time.Second)
			mutex.RUnlock()
			// 읽기 뮤텍스 해제
		}
	}()

	time.Sleep(10 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

package main

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

func main() {
	// 시스템 전체 CPU 사용
	runtime.GOMAXPROCS(runtime.NumCPU())

	var mutex = new(sync.Mutex)
	var condition = sync.NewCond(mutex)

	ch := make(chan int, 5) // 비동기 버퍼 채널

	for i := 0; i < 5; i++ {
		go func(n int) {
			mutex.Lock()
			ch <- 777
			fmt.Println("GoRoutine Wait -> ", n)
			condition.Wait() // 고 루틴 멈춤(대기)
			fmt.Println("Waiting End", n)
			mutex.Unlock()
		}(i)
	}

	for i := 0; i < 5; i++ {
		// <- ch
		fmt.Println("Received : ", <-ch )
	}

	/*for i := 0; i < 5; i++ {
		mutex.Lock()
		fmt.Println("Wake GoRoutine(Signal)", i)
		condition.Signal() // 모든 고 루틴 생성 후 한개 씩 깨우기
		mutex.Unlock()
	}*/

	mutex.Lock()
	fmt.Println("Wake Goroutine(Broadcast)")
	condition.Broadcast()
	mutex.Unlock()

	time.Sleep(2 * time.Second)
}

1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

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

func onceTest() {
	// 이 부분에 한 번 실행 할 코드 작성
	// 초기화 작업 등
	fmt.Println("Once Test Execute!")
}

func main() {

	runtime.GOMAXPROCS(runtime.NumCPU())

	once := new(sync.Once) // Once 객체 생성

	for i := 0; i < 5; i++ {
		go func(n int) {
			fmt.Println("Go Routine -> ", n)
			once.Do(onceTest)
		}(i)
	}

	time.Sleep(2 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
	"fmt"
	"sync"
)

// 고루틴 동기화 고급 - 2
func main() {

	wg := new(sync.WaitGroup)

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(n int) {
			fmt.Println("WaitGroup => ", n)
			wg.Done()
		}(i)
	}

	// Add 와 Done 횟수가 같아야한다.
	wg.Wait() // 대기 그룹이 끝날떄까지 기다린다.
	fmt.Println("WaitGroup End!")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {

	// 원자성을 사용하지 않은 경우 예제
	runtime.GOMAXPROCS(runtime.NumCPU())

	var cnt int64 = 0
	wg := new(sync.WaitGroup)

	for i := 0; i < 5000; i++ {
		wg.Add(1)
		go func(n int) {
			cnt += 1
			wg.Done()
		}(i)
	}

	for i := 0; i < 2000; i++ {
		wg.Add(1)
		go func(n int) {
			cnt -= 1
			wg.Done()
		}(i)
	}

	wg.Wait() // 대기 그룹이 끝날떄까지 기다린다.
	fmt.Println("WaitGroup End! cnt : ", cnt)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package main

import (
	"fmt"
	"runtime"
	"sync"
	"sync/atomic"
)

// 고루틴 동기화 고급 - 3
func main() {

	runtime.GOMAXPROCS(runtime.NumCPU())

	var cnt int64 = 0
	wg := new(sync.WaitGroup)

	for i := 0; i < 5000; i++ {
		wg.Add(1)
		go func(n int) {
			//cnt += 1
			atomic.AddInt64(&cnt, 1)
			wg.Done()
		}(i)
	}

	for i := 0; i < 2000; i++ {
		wg.Add(1)
		go func(n int) {
			//cnt -= 1
			atomic.AddInt64(&cnt, -1)
			wg.Done()
		}(i)
	}

	wg.Wait() // 대기 그룹이 끝날떄까지 기다린다.

	finalCnt := atomic.LoadInt64(&cnt)
	fmt.Println("WaitGroup End! cnt : ", cnt)
	fmt.Println("WaitGroup End! cnt : ", finalCnt)
}