I am learning GOLANG, in particular for its concurrency capabilities.
Have tried to further develop one of the worker_pool examples so that each worker receives a job id and a job load, represented in a random duration of the job.
The duration is used by a time.sleep command to wait the alloted number of nano seconds, which are calculated randomly.
Code looks like this...
//worker_pool improved example
package main
import "fmt"
import "time"
import "math/rand"
// Here's the worker, of which we'll run several
// concurrent instances. These workers will receive
// work on the `jobs` channel and send the corresponding
// results on `results`. We'll sleep a random number of seconds between
// 1 and 5 to simulate an expensive task.
func worker(id int, jobs <-chan int, loads <-chan time.Duration, results chan<- int) {
for j := range jobs {
fmt.Println("worker", id, "started job", j, time.Now())
time.Sleep(loads*time.Second)
fmt.Println("worker", id, "finished job", j, time.Now())
results <- j * 2
}
}
func main() {
// In order to use our pool of workers we need to send
// them work and collect their results. We make 2
// channels for this.
jobs := make(chan int)
loads := make(chan time.Duration)
results := make(chan int)
// This starts up 3 workers, initially blocked
// because there are no jobs yet.
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
// Here we send 24 `jobs` and then `close` that
// channel to indicate that's all the work we have.
for j := 1; j <= 24; j++ {
jobs <- j
r := rand.New(rand.NewSource(99))
load := r.Int63n(5000000)
loads <- load
}
close(jobs)
close(loads)
// Finally we collect all the results of the work.
for a := 1; a <= 24; a++ {
<-results
}
}
I keep getting this error messages...
prog.go:18:33: cannot convert loads (type <-chan int) to type time.Duration
prog.go:36:18: not enough arguments in call to worker have (int, chan int, chan int) want (int, <-chan int, <-chan int, chan<- int)
prog.go:45:15: cannot use load (type int64) as type int in send
What am I doing wrong?