练习题1

要求：
1、启动1个协程，将1~2000个数放进channel里，比如为newChan
2、启动10个协程，从newChan中取出数据n,并计算1+..+n的值，将其存入新的channel中，比如retChan
3、打印retChan的结果，比如ret[1]=1….

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. /*
  9. 练习题：
  10. 1、启动1个协程，将1~2000个数放进channel里，比如为newChan
  11. 2、启动10个协程，从newChan中取出数据n,并计算1+..+n的值，将其存入新的channel中，比如retChan
  12. 3、打印retChan的结果，比如ret[1]=1....
  13. */
  15. var wg sync.WaitGroup
  17. func writeData(newChan chan int) {
  18.     // 向里面写入1~2000个数字
  19.     for i := 1; i <= 2000; i++ {
  20.         newChan <- i
  21.     }
  22.     close(newChan)
  23. }
  25. func readData(newChan chan int, retChan chan map[int]int) {
  27.     for {
  28.         data, ok := <-newChan
  29.         if !ok {
  30.             break
  31.         }
  32.         ret := 0
  33.         for i := 0; i < data; i++ {
  34.             ret += i
  35.         }
  36.         retMap := make(map[int]int)
  37.         retMap[data] = ret
  38.         retChan <- retMap
  39.         defer wg.Done()
  40.     }
  41.     // close(retChan)
  42. }
  44. func main() {
  45.     // 初始channel
  46.     newChan := make(chan int, 2000)
  47.     retChan := make(chan map[int]int, 2000)
  48.     wg.Add(2000)
  49.     go writeData(newChan)
  50.     // 开启8个线程去读写
  51.     for i := 0; i < 8; i++ {
  52.         go readData(newChan, retChan)
  53.     }
  54.     wg.Wait()
  55.     close(retChan)
  56.     for data := range retChan {
  57.         // fmt.Println(data)
  58.         for key, value := range data {
  59.             fmt.Printf("ret[%d]=%d\n", key, value)
  60.         }
  61.     }
  62. }

练习题2

要求：
1、开启1个协程writeDataToFile，随机生产1000个数字，存放到文件中
2、当writeDataToFile完成1000个数字写入后，让sort协程从中读取1000个数据对其进行排序，并将排序好的数字存入新的文件中

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "io"
  7.     "math/rand"
  8.     "os"
  9.     "sort"
  10.     "strconv"
  11.     "strings"
  12.     "sync"
  13. )
  15. /*
  16. 1、开启1个协程writeDataToFile，随机生产1000个数字，存放到文件中
  17. 2、当writeDataToFile完成1000个数字写入后，让sort协程从中读取1000个数据对其进行排序，并将排序好的数字存入新的文件中
  18. */
  20. var wg sync.WaitGroup
  22. func writeDataToFile(fileChan chan bool) {
  23.     writeFile, err := os.OpenFile("./random.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
  24.     if err != nil {
  25.         fmt.Println("open file failed, err:", err)
  26.         return
  27.     }
  28.     defer writeFile.Close()
  29.     for i := 1; i <= 1000; i++ {
  30.         // 生成随机数
  31.         randomNum := rand.Int31() % 10000
  32.         // 将随机数保存到文件中
  33.         writeFile.WriteString(strconv.Itoa(int(randomNum)) + "\n")
  34.     }
  35.     fileChan <- true
  36.     close(fileChan)
  37. }
  39. func sortData(fileChan chan bool) {
  40.     for {
  41.         ret, ok := <-fileChan
  42.         if !ok {
  43.             break
  44.         }
  45.         if ret {
  46.             readFile, err := os.Open("./random.txt")
  47.             if err != nil {
  48.                 fmt.Println("read file failed, err:", err)
  49.             }
  50.             defer readFile.Close()
  51.             newFile, err := os.OpenFile("./newfile.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
  52.             if err != nil {
  53.                 fmt.Println("open new file failed, err:", err)
  54.                 return
  55.             }
  56.             defer newFile.Close()
  57.             newReader := bufio.NewReader(readFile)
  58.             // 逐行读取，将其转换为int，存到slice中
  59.             var newSlice []int
  60.             for {
  61.                 line, err := newReader.ReadString('\n')
  62.                 if err == io.EOF {
  63.                     break
  64.                 }
  65.                 if err != nil {
  66.                     fmt.Println(err)
  67.                 }
  68.                 // fmt.Println()
  69.                 ret, _ := strconv.Atoi(strings.Split(line, "\n")[0])
  70.                 // fmt.Println(ret)
  71.                 // fmt.Printf("%T\n", ret)
  72.                 newSlice = append(newSlice, ret)
  74.             }
  75.             // fmt.Println(newSlice)
  76.             // 对切片进行排序
  77.             // fmt.Println(len(newSlice))
  78.             sort.Ints(newSlice)
  79.             // fmt.Println(len(newSlice))
  80.             // 将排序好的数据写入新文件
  81.             for _, v := range newSlice {
  82.                 newFile.WriteString(strconv.Itoa(v) + "\n")
  83.             }
  84.             defer wg.Done()
  85.             // close(exitChan)
  86.         }
  87.     }
  88. }
  90. func main() {
  91.     // 定义一个channel，用来记录文件已经写完
  92.     fileChan := make(chan bool, 1)
  93.     // exitChan := make(chan bool, 1)
  94.     wg.Add(1)
  95.     go writeDataToFile(fileChan)
  96.     // go sortData(fileChan, exitChan)
  97.     go sortData(fileChan)
  98.     // for {
  99.     //     _, ok := <-exitChan
  100.     //     if !ok {
  101.     //         break
  102.     //     }
  103.     // }
  104.     wg.Wait()
  105. }

扩展：
1、开启10个协程writeDataToFile，随机生产1000个数字，存放到10文件中
2、当writeDataToFile完成10个文件1000个数字写入后，让sort协程从10个文件中读取1000个数据对其进行排序，并将排序好的数字存入新的10的文件中

练习题3

使用goroutine和channel实现一个计算int64随机数各位数和的程序。
1、开启一个goroutine循环生成int64类型的随机数，发送到jobChan
2、开启24个goroutine从jobChan中取出随机数计算各位数的和，将结果发送到resultChan
3、主goroutine从resultChan取出结果并打印到终端输出

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "sync"
  7.     "time"
  8. )
  10. /*
  11. 使用goroutine和channel实现一个计算int64随机数各位数和的程序。
  12. 1、开启一个goroutine循环生成int64类型的随机数，发送到jobChan
  13. 2、开启24个goroutine从jobChan中取出随机数计算各位数的和，将结果发送到resultChan
  14. 3、主goroutine从resultChan取出结果并打印到终端输出
  15. */
  17. type job struct {
  18.     value int64
  19. }
  21. type result struct {
  22.     job *job
  23.     sum int64
  24. }
  26. var wg sync.WaitGroup
  28. func insertData(ch1 chan<- *job) {
  29.     defer wg.Done()
  30.     // 循环写
  31.     for {
  32.         // 生成随机数
  33.         num := rand.Int63()
  34.         // 实例化job
  35.         numJob := &job{
  36.             value: num,
  37.         }
  38.         ch1 <- numJob
  39.         time.Sleep(time.Millisecond * 500)
  40.     }
  41. }
  43. func sumData(ch1 <-chan *job, retChan chan<- *result) {
  44.     defer wg.Done()
  45.     for {
  46.         // 循环从ch1读数据
  47.         num := <-ch1
  48.         sum := int64(0)
  49.         // 计算位数之和
  50.         n := num.value
  51.         for n > 0 {
  52.             sum += n % 10
  53.             n = n / 10
  54.         }
  55.         // 实例化result
  56.         newResult := &result{
  57.             job: num,
  58.             sum: sum,
  59.         }
  60.         retChan <- newResult
  61.     }
  62. }
  64. func main() {
  65.     inChan := make(chan *job, 100)
  66.     retChan := make(chan *result, 100)
  67.     wg.Add(1)
  68.     go insertData(inChan)
  69.     for i := 1; i <= 24; i++ {
  70.         wg.Add(1)
  71.         go sumData(inChan, retChan)
  72.     }
  73.     // 打印结果
  74.     for ret := range retChan {
  75.         fmt.Printf("Job: [%d] Sum: [%d]\n", ret.job.value, ret.sum)
  76.     }
  77.     wg.Wait()
  79. }