```go
package main
import (
"fmt"
_ "reflect"
"sync"
"time"
)
func writeData(intChan chan int) {
for i := 1; i <= 8000; i++ {
intChan <- i
//fmt.Printf("writeData()写入数据%v", i)
}
close(intChan)
//fmt.Println(intChan)
}
func judgData(intChan chan int, resultChan chan int, exitChan chan bool, done func()) {
defer done()
time.Sleep(time.Millisecond * 1000)
flag := true
//time.Sleep(time.Second *1)
for {
num, ok := <-intChan
if !ok {
fmt.Println("已从intChan读取所有数据")
break
}
for i := 2; i < num; i++ {
if num % i == 0 {
flag = false
break
}
if flag {
resultChan <- num
fmt.Printf("添加%v到resultChan\n", num)
}
}
}
fmt.Println("协程执行完毕")
exitChan <- true
}
func main() {
var wg sync.WaitGroup
intChan := make(chan int, 10000)
resultChan := make(chan int, 20000)
exitChan := make(chan bool, 8)
go writeData(intChan)
for i := 0; i < 8; i++ {
go judgData(intChan, resultChan, exitChan, wg.Done)
}
//go func() {
// for i := 0 ; i < 8 ; i ++ {
// key := <-exitChan
// fmt.Print(key)
// }
// close(resultChan)
//}()
wg.Add(8)
wg.Wait()
close(resultChan)
func() {
for i := 0; i < 8; i++ {
key := <-exitChan
fmt.Printf("key=%v\n", key)
}
}()
for {
res, ok := <-resultChan
if !ok {
break
}
fmt.Printf("素数=%d\n", res)
}
}
```
给两个小建议吧
1、关闭的channel可以用for range 来循环，所以最后打印素数的时候，可以写成
```go
for key := range resultChan {
fmt.Printf("素数：%v\n", key)
}
```
2、写代码的时候，最好业务跟逻辑分离处理，比如把判断是否是素数的方法拆出来
```go
func judgData(intChan chan int, resultChan chan int, exitChan chan bool) {
for {
num, ok := <-intChan
if !ok {
fmt.Println("数据读取完毕")
break
}
if isPrime(num) {
resultChan <- num
}
}
exitChan <- true
fmt.Println("一个协程执行完毕")
}
func isPrime(n int) bool {
if n < 2 {
return false
}
for i := 2; i*i <= n; i++ {
if n%i == 0 {
return false
}
}
return true
}
```
其他的就是一些个人习惯了，练习项目都无所谓
* 比如多个相邻的变量声明，我喜欢用var()包起来
* 比如多次用到的值，可以用常量代替
* 比如开多个协程的时候，我习惯用WaitGroup或Context来处理
#8
更多评论
今日阅读排行
一周阅读排行