Write an example of goroutine and practice Chan at the same time

sketch

It's essentially a producer consumer model

• By controlling goroutine Number , Prevent inflation
• demand ：
  – Calculate the sum of the digits of a number , For example, digital 123, The result is 1+2+3=6
  – Randomly generated numbers for calculation

Code ：

package main

import (
	"fmt"
	"math/rand"
	"time"
)

//  producer 
type Job struct {
    
	Id      int //  Number 
	RandNum int //  The resulting random value 
}

//  consumer 
type Result struct {
    
	job *Job //  Incoming object instance  why？
	sum int  //  Sum value 
}

//  Create a work pool 
//  Parameters 1：  Open several cooperation programs 
func createPool(num int, jobChan chan *Job, resultChan chan *Result) {
    
	//  According to the number of processes   To run 
	for i := 0; i < num; i++ {
    
		go func(jC chan *Job, rC chan *Result) {
    
			//  Perform an operation 
			//  Traverse  job  All data of the pipeline , Add additivity 
			for job := range jC {
    
				//  Random numbers come in 
				r_num := job.RandNum

				//  Each bit of random number is added 
				// sum  The sum of digits returns the value 
				var sum int = 0
				for r_num != 0 {
    
					tmp := r_num % 10
					sum += tmp
					r_num /= 10
				}

				//  Want to put the results in  Result
				r := &Result{
    
					job: job,
					sum: sum,
				}
				//  Calculation results   to  chan
				rC <- r
			}
		}(jobChan, resultChan)
	}
}

func main() {
    
	//  need  2  individual chan Used to pass in numbers   and   evaluation 
	// 1. job  The Conduit 
	jobChan := make(chan *Job, 128)
	// 2. result  The Conduit 
	resultChan := make(chan *Result, 128)

	// 3.  Create a work pool 
	createPool(64, jobChan, resultChan)

	// 4.  utilize  goroutine  Print data 
	go func(ch chan *Result) {
    
		//  Traversal result pipeline printing 
		for result := range ch {
    
			fmt.Printf("job id: %v\trandnum: %v\tresult: %v\n", result.job.Id,
				result.job.RandNum, result.sum)
		}
	}(resultChan)

	var id int = 0
	var count int = 20 // Only calculate  20  Group data 
	//  Loop creation  job,  Input to pipeline 
	for count > 0 {
    
		
		time.Sleep(time.Second) //  Otherwise, the cooperation process will run 20 Times too fast 
		count--
		id++

		//  Generate random number 
		r_num := rand.Int() //  Here is generating a nonnegative number , [0, 2^64)
		job := &Job{
    
			Id:      id,
			RandNum: r_num,
		}
		jobChan <- job

	}
}