GoWeb——并发实例

刺骨的言语ヽ痛彻心扉 2023-10-12 11:48 33阅读 0赞

#### 目录 ####

*   *  1、自增整数生成器
     *  2、并发的消息发送器
     *  3、多路复合计算器
     *  4、select创建多通道监听器
     *  5、用无缓冲通道阻塞主线
     *  6、筛法求素数
     *  7、随机数生成器
     *  8、定时器

### 1、自增整数生成器 ###

import "fmt"
    
    func main() {
        
    	generator := IntegerGenerator()
    	for i := 0; i < 100; i++ {
         // 生成100个自增的整数
    		fmt.Println(<-generator)
    	}
    }
    
    //生成自增的整数
    func IntegerGenerator() chan int {
        
    	var ch chan int = make(chan int)
    	//开启goroutine
    	go func() {
        
    		for i := 0; ; i++ {
        
    			ch <- i //直到通道索要数据才把i添加进通道
    		}
    	}()
    	return ch
    }

### 2、并发的消息发送器 ###

import "fmt"
    
    func main() {
        
    	barry := SendNotification("barry")
    	shirdon := SendNotification("shirdon")
    
    	fmt.Println(<-barry)
    	fmt.Println(<-shirdon)
    }
    
    func SendNotification(user string) chan string {
        
    	//此处省略查询数据库获取新消息
    	//声明一个通道来保存消息
    	notifications := make(chan string, 500)
    	//开启一个通道
    	go func() {
        
    		//将消息放入通道
    		notifications <- fmt.Sprintf("Hi %s, welcome to our site!", user)
    	}()
    	return notifications
    }

### 3、多路复合计算器 ###

import (
    	"fmt"
    	"math/rand"
    	"time"
    )
    
    // 多路复合计算器
    func main() {
        
    	//返回复合后的结果
    	result := Recombination(branch(10), branch(20), branch(30))
    	for i := 0; i < 3; i++ {
        
    		fmt.Println(<-result)
    	}
    }
    
    // 这个函数可以用来处理比较耗时的事情，比如计算
    func doCompute(x int) int {
        
    	time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
    	return 1 + x //假如1+x是一个很费时的计算
    }
    
    // 每个分支开出1个goroutine来计算，并把计算结果发送到各自通道中
    func branch(x int) chan int {
        
    	ch := make(chan int)
    	go func() {
        
    		ch <- doCompute(x)
    	}()
    	return ch
    }
    
    func Recombination(chs ...chan int) chan int {
        
    	ch := make(chan int)
    	for _, c := range chs {
        
    		//注意此处要明确传值
    		go func(c chan int) {
        
    			ch <- <-c
    		}(c) //复合
    	}
    	return ch
    }

11
    31
    21

### 4、select创建多通道监听器 ###

import "fmt"
    
    func main() {
        
    	ch1, ch2, ch3 := foo(3), foo(6), foo(9)
    	ch := make(chan int)
    
    	//开启一个goroutine监听各个通道数据输出，并收集数据到通道ch中
    	go func() {
        
    		for {
        
    			//监视通道ch1,ch2,ch3的输出，并全部输入通道ch中
    			select {
        
    			case v1 := <-ch1:
    				ch <- v1
    			case v2 := <-ch2:
    				ch <- v2
    			case v3 := <-ch3:
    				ch <- v3
    			}
    		}
    	}()
    	//阻塞主线，取出通道ch中的数据
    	for i := 0; i < 3; i++ {
        
    		fmt.Println(<-ch)
    	}
    }
    
    func foo(i int) chan int {
        
    	ch := make(chan int)
    	go func() {
        
    		ch <- i
    	}()
    	return ch
    }

有了select,把在多路复合代码Recombination()函数再优化一下，这样就不用开多个goroutine来接收数据了。代码如下：

func Recombination(chs ...chan int) chan int {
        
    	ch := make(chan int)
    	//select会尝试着依次去除各个通道中的数据
    	go func() {
        
    		for i := 0; i < len(chs); i++ {
        
    			select {
        
    			case v1 := <-chs[i]:
    				ch <- v1
    			}
    		}
    	}()
    	return ch
    }

在使用select时，有时需要做超时处理。示例如下：

//timeout是一个计时通道，如果到时间了则会发一个信号出来
    timeout := time.After(1 * time.Second)
    for isTimeout := false; !isTimeout; {
        
    	se1ect{
        //监视通道chl、ch2、ch3、timeout中的数据输出
    	case vl := <-chl:
    		fmt.Printf("received &d from chl",vl)
    	case v2 := <-ch2:
    		fmt.Printf("received &d from ch2",v2)
    	case v3 := <-ch3:
    		fmt.Printf ("received d from ch3",v3)
    	case <-timeout:
    		isTimeout=true//超时
    	}
    }

### 5、用无缓冲通道阻塞主线 ###

通道的一个很常用的应用，它使用无缓冲通道来阻塞主线，等待goroutine结束。这样就不必再使用timeout来做超时处理。用无缓冲通道来阻塞主线的示例如下。

import "fmt"
    
    func main() {
        
    	ch, quit := make(chan int), make(chan int)
    	go func() {
        
    		ch <- 8   //添加数据
    		quit <- 1 //发送完成信号
    	}()
    
    	for isQuit := false; !isQuit; {
        
    		//监听通道ch的数据输出
    		select {
        
    		case v := <-ch:
    			fmt.Printf("received %d from ch", v)
    		case <-quit:
    			isQuit = true //通道quit有输出，关闭for循环
    		}
    	}
    }

### 6、筛法求素数 ###

用筛法求素数的基本思想是：把从1开始的、某个范围内的正整数从小到大顺序排列；1不是素数，首先把它筛掉；在剩下的数中最小的数是素数，去掉它的倍数；依次类推，直到筛子为空时结束。如有如下整数：

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

1不是素数，去掉。在剩下的数中2最小，是素数，需要去掉2的倍数。余下的数是：

3 5 7 9 11 13 15 17 19 21 23 25 27 29
    ``
    在剩下的数中，3最小，是素数，需要去掉3的倍数。如此下去直到所有的数都被筛完。最终求出的素数如下：

2 3 5 7 11 13 17 19 23 29

```go
    import "fmt"
    
    func main() {
    	const max = 100
    	numbers := IntegerGenerator()
    	number := <-numbers
    
    	for number <= max { //用number作为筛子，当筛子超过max时结束
    		fmt.Println(number)
    		numbers = Filter(numbers, number)
    		number = <-numbers
    	}
    }
    
    //生成自增的整数
    func IntegerGenerator() chan int {
    	var ch chan int = make(chan int)
    	go func() {
    		for i := 2; ; i++ {
    			ch <- i //直到通道索要所属，才把i添加进通道
    		}
    	}()
    	return ch
    }
    
    func Filter(in chan int, number int) chan int {
    	//in:输入队列
    	//输入一个整数队列，筛出是number的倍数的数，将不是number的倍数的数放入输出队列中
    	out := make(chan int)
    	go func() {
    		for {
    			i := <-in
    			if i%number != 0 {
    				out <- i
    			}
    		}
    	}()
    	return out
    }

### 7、随机数生成器 ###

import "fmt"
    
    //0/1随机生成
    func main() {
        
    	generator := randGenerator()
    	for i := 0; i < 10; i++ {
        
    		fmt.Println(<-generator)
    	}
    }
    
    func randGenerator() chan int {
        
    	ch := make(chan int)
    
    	go func() {
        
    		for {
        
    			//select会尝试执行各个case,如果都可以执行则随机选取其中一个执行
    			select {
        
    			case ch <- 0:
    			case ch <- 1:
    			}
    		}
    	}()
    	return ch
    }

### 8、定时器 ###

import (
    	"fmt"
    	"time"
    )
    
    func main() {
        
    	//定时5s
    	timeout := Timer(5 * time.Second)
    	for {
        
    		select {
        
    		case <-timeout:
    			fmt.Println("already 5s!")
    			return
    		}
    	}
    }
    
    func Timer(duration time.Duration) chan bool {
        
    	ch := make(chan bool)
    
    	go func() {
        
    		time.Sleep(duration)
    		//到时间了
    		ch <- true
    	}()
    	return ch
    }