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

func produce(ch chan<- int) {  
   for i := 0; i < 10; i++ {  
      ch <- i + 1  
      time.Sleep(time.Second)  
   }  
   close(ch)  
   defer wg.Done()  
}  
  
func consume(ch <-chan int) {  
   for v := range ch {  
      println(v)  
   }  
   defer wg.Done()  
}  

func TestProducer(t *testing.T) {  
   ch := make(chan int, 5)  
   wg.Add(2)  
  
   go produce(ch)  
   go consume(ch)  
   wg.Wait()  
  
}

1
2
3

ch := make(chan int, 5)
close(ch)
ch <- 13 // panic: send on closed channel

 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

type signal struct {  
}  
  
func worker() {  
   println("worker is working")  
   time.Sleep(1 * time.Second)  
}  
  
func spawn(f func()) <-chan signal {  
   c := make(chan signal)  
   go func() {  
      println("worker start to work...")  
      f()  
      c <- signal{}  
   }()  
   return c  
}  
  
func TestSignal(t *testing.T) {  
   println("main start a worker.....")  
   c := spawn(worker)  
   <-c  
   fmt.Println("worker work done!")  
  
}

1
2
3
4

main start a worker.....
worker start to work...
worker is working
worker work done!

 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

func worker1(i int) {  
   fmt.Printf("worker %d: is working...\n", i)  
   time.Sleep(1 * time.Second)  
   fmt.Printf("worker %d: works done\n", i)  
}  
  
func spawnGroup(f func(i int), num int, grouSignal <-chan signal) <-chan signal {  
  
   c := make(chan signal)  
   // Num个goroutine  
   for i := 0; i < num; i++ {  
      wg.Add(1)  
      go func(i int) {  
         <-grouSignal //阻塞点  
         fmt.Printf("worker %d: start to work...\n", i)  
         f(i)  
         wg.Done()  
      }(i + 1)  
   }  
  
   go func() {  
      wg.Wait()  
      c <- signal{}  
   }()  
   return c  
}  
  
func TestSignal2(t *testing.T) {  
   fmt.Println("start a group of workers...")  
   groupSignal := make(chan signal)  
   c := spawnGroup(worker1, 5, groupSignal)  
   time.Sleep(5 * time.Second)  
   fmt.Println("the group of workers start to work...")  
   close(groupSignal) // 关闭了  
   <-c  
   fmt.Println("the group of workers work done!")  
}

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

start a group of workers...
the group of workers start to work...
worker 1: start to work...
worker 3: start to work...
worker 1: is working...
worker 2: start to work...
worker 2: is working...
worker 5: start to work...
worker 5: is working...
worker 3: is working...
worker 4: start to work...
worker 4: is working...
worker 4: works done
worker 5: works done
worker 3: works done
worker 2: works done
worker 1: works done
the group of workers work done!
--- PASS: TestSignal2 (6.02s)

 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

type counter struct {  
   sync.Mutex  
   i int  
}  
  
var cter counter  
  
// 加锁解锁，i+1  
func Increase() int {  
   cter.Lock()  
   defer cter.Unlock()  
   cter.i++  
   return cter.i  
}  
  
func TestNoBuffer(t *testing.T) {  
   for i := 0; i < 10; i++ {  
      wg.Add(1)  
      go func(i int) {  
         v := Increase()  
         fmt.Printf("goroutine-%d: current counter value is %d\n", i, v)  
         wg.Done()  
      }(i)  
   }  
   wg.Wait()  
}

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

=== RUN   TestNoBuffer
goroutine-9: current counter value is 1
goroutine-0: current counter value is 2
goroutine-1: current counter value is 3
goroutine-2: current counter value is 4
goroutine-3: current counter value is 5
goroutine-4: current counter value is 6
goroutine-5: current counter value is 7
goroutine-6: current counter value is 8
goroutine-7: current counter value is 9
goroutine-8: current counter value is 10
--- PASS: TestNoBuffer (0.00s)
PASS

 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

type counterchan struct {  
   c chan int  
   i int  
}  
  
func NewCounter() *counterchan {  
   cter := &counterchan{  
   // 这是无缓冲的chan
      c: make(chan int),  
   }  
   go func() {  
   // 无限循环，会阻塞在这里
      for {  
         cter.i++  // i+1
         cter.c <- cter.i  //发送给chan，这是必须有人接收，否则会阻塞在这
      }    
   }()  
   // 返回chan
   return cter  
}  
  
// 返回channel里的数值
func (cter *counterchan) Increase() int {  
   return <-cter.c  
}  
  
func TestChanMutex(t *testing.T) { 
   // 
   cter := NewCounter()  
  
   for i := 0; i < 10; i++ {  
      wg.Add(1)  
      go func(i int) {  
         v := cter.Increase() // 这里开始接收。
         fmt.Printf("goroutine-%d: current counter value is %d\n", i, v)  
         wg.Done()  
      }(i)  
   }  
   wg.Wait()  
}