golang concurrent

go and channel

use slice of channel

package main
import "fmt"
func Count(ch chan int, i int) {
     ch <- i
 }
 func main() {
     chs := make([]chan int, 10) //create 10 cap slice
     for i := 0; i < 10; i++ {
         ch := make(chan int)
         chs[i] = ch
         go Count(ch, i)
     }
     for _, v := range chs {
         fmt.Println(<-v) //will wait every element return
     }
}
====
output:
0
1
2
3
4
5
6
7
8
9

use range(remember that need to close)

package main
import (
     "fmt"
 )
func producer(chnl chan int) {
     for i := 0; i < 10; i++ {
         chnl <- i 
     }
     close(chnl) 
}
 
func main() {
     ch := make(chan int, 10)
     go producer(ch) //NOTE: we don't loop in here , will loop in producer
     for v := range ch {
         fmt.Println("Received", v)
     }
 }
====
output:
Received  0
Received  1
Received  2
Received  3
Received  4
Received  5
Received  6
Received  7
Received  8
Received  9

NOTE: not guarantee ordering( if you don’t mind)

package main
import "fmt"
func Count(ch chan int, i int) {
     fmt.Println("Counting", i)
     ch <- i
 }
 func main() {
     chs := make(chan int)
     for i := 0; i < 10; i++ {
         go Count(chs, i)
     }
     for i := 0; i < 10; i++ {
         <- chs
     }
 }
=======
output:
Counting 0
Counting 7
Counting 6
Counting 1
Counting 5
Counting 4
Counting 2
Counting 8
Counting 9
Counting 3

— — —

lock

var l sync.Mutex 
func foo() {
       l.Lock()
       defer l.Unlock()
        //...
}

—

only run once

var once sync.Once
...
func setup () {
   ...
}
func foo () {
   once.Do(setup)
}
func main() {
  go foo()
  go foo()
}