• Google资深工程师深度讲解Go语言channel 通道 (十)


    一.channel

    • channel
    • buffered channel
    • range.由发送方结束发送
    • 理论基础:communication sequential process(csp)
    • 不要通过共享内存来通信;通过通信来共享内存
    package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func chanDemo() {
    	c := make(chan int)
    	go func() {
    		for {
    			n := <-c
    			fmt.Println(n)
    			//Output:
    			// 1
    			//2
    		}
    	}()
    	c <- 1
    	c <- 2
    	time.Sleep(time.Microsecond)
    }
    
    func main() {
    	chanDemo()
    }
    
    package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func worker(id int, c chan int) {
    	for n := range c {
    		//n := <-c //收数据
    		//n, ok := <-c
    		//if !ok {
    		//	break
    		//}
    
    		fmt.Printf("worker %d received %d\n", id, n)
    
    		//fmt.Println(n)
    		//Output:
    		// 1
    		//2
    	}
    
    }
    func createWorker(id int, ) chan<- int { //返回channel
    	c := make(chan int)
    	go worker(id, c)
    	return c
    }
    func chanDemo() {
    	//var c chan int //变量c 是个chanel 里面内容是int
    	//c := make(chan int)
    
    	var channels [10]chan<- int
    	for i := 0; i < 10; i++ {
    		channels[i] = createWorker(i)
    	}
    
    	for i := 0; i < 10; i++ {
    		channels[i] <- 'a' + i
    	}
    	for i := 0; i < 10; i++ {
    		channels[i] <- 'A' + i
    	}
    
    	//c <- 1  //发数据
    	//c <- 2
    	time.Sleep(time.Microsecond)
    }
    
    func bufferedChannel() {
    	c := make(chan int, 3)
    	go worker(0, c)
    	c <- 'a'
    	c <- 'b'
    	c <- 'c'
    	c <- 'd'
    	time.Sleep(time.Microsecond)
    }
    func channelClose() { //发送方通知接收方
    	c := make(chan int, 3)
    	go worker(0, c)
    	c <- 'a'
    	c <- 'b'
    	c <- 'c'
    	c <- 'd'
    	close(c)
    	time.Sleep(time.Microsecond)
    }
    func main() {
    	fmt.Println("channel ad first-class citizen")
    	chanDemo()
    
    	fmt.Println("Buffered channel")
    	bufferedChannel()
    
    	fmt.Println("Channel close and range")
    	channelClose()
    }
    

    二.传统同步机制

    • waitGroup :等待组
    • Mutex 互斥
    • Cond
    package main
    
    import (
    	"fmt"
    	"sync"
    	"time"
    )
    
    type atomicInt struct {
    	value int
    	lock sync.Mutex
    }
    
    func (a *atomicInt)increment()  {
    	a.lock.Lock()
    	defer a.lock.Unlock()
    	a.value++
    }
    
    func (a *atomicInt)get()int  {
    	a.lock.Lock()
    	defer a.lock.Unlock()
    	return a.value
    }
    
    func main() {
    	var a atomicInt
    	a.increment()
    	go func() {
    		a.increment()
    	}()
    	time.Sleep(time.Second)
    	fmt.Println(a.get())
    }
    

    赞赏码

    非学,无以致疑;非问,无以广识

  • 相关阅读:
    test1
    servlet的生命周期
    关与JdbcTemplate"的thread "main" org.springframework.jdbc.BadSqlGrammarException
    正则表达式
    @Autowired和@Resource的区别
    kubernetes安装
    docker相关
    KIBANA
    mysql在centos上安装
    MySql不错的文章
  • 原文地址:https://www.cnblogs.com/lxwphp/p/15452736.html
Copyright © 2020-2023  润新知