fork download
copy 
  1. package main
  2.  
  3. import (
  4. 	"fmt"
  5. 	"sync"
  6. 	"time"
  7. )
  8.  
  9. func sumUsingParallelWorkers(start int64, end int64, results []int64, index int, wg *sync.WaitGroup) {
  10. 	defer wg.Done()
  11. 	var localSum int64 = 0
  12. 	for i := start; i <= end; i++ {
  13. 		localSum += i
  14. 	}
  15. 	results[index] = localSum
  16. }
  17. func main() {
  18. 	var n int64 = 100000000
  19. 	var workerCountForSum = 4
  20.  
  21. 	var tempSum int64 = 0
  22. 	fmt.Println("Calculating sum from 1 to", n, "using single loop")
  23. 	var startTime = time.Now()
  24. 	for i := int64(1); i <= n; i++ {
  25. 		tempSum += i
  26. 	}
  27. 	var duration = time.Since(startTime)
  28. 	fmt.Println("Sum using single loop =", tempSum)
  29. 	fmt.Println("Time taken for sum using single loop = ", duration)
  30.  
  31. 	var wg sync.WaitGroup
  32. 	fmt.Println("\nCalculating sum from 1 to", n, "using", workerCountForSum, "parallel workers")
  33. 	chunkSize := n / int64(workerCountForSum)
  34. 	results := make([]int64, workerCountForSum)
  35. 	startTime = time.Now()
  36. 	wg.Add(workerCountForSum)
  37. 	go sumUsingParallelWorkers(1, chunkSize, results, 0, &wg)
  38. 	go sumUsingParallelWorkers(chunkSize+1, chunkSize*2, results, 1, &wg)
  39. 	go sumUsingParallelWorkers(chunkSize*2+1, chunkSize*3, results, 2, &wg)
  40. 	go sumUsingParallelWorkers(chunkSize*3+1, n, results, 3, &wg)
  41. 	wg.Wait()
  42.  
  43. 	var parallelSum int64 = 0
  44.  
  45. 	for _, value := range results {
  46. 		parallelSum += value
  47. 	}
  48.  
  49. 	duration = time.Since(startTime)
  50.  
  51. 	fmt.Println("Sum using parallel workers =", parallelSum)
  52. 	fmt.Println("Time taken for sum using parallel workers =", duration)
  53.  
  54. 	fmt.Println("All workers finished")
  55. }
  56.  
Success #stdin #stdout 0.07s 5324KB
comments (?)
stdin
copy 
1
stdout
copy 
Calculating sum from 1 to 100000000 using single loop
Sum using single loop = 5000000050000000
Time taken for sum using single loop =  38.604786ms

Calculating sum from 1 to 100000000 using 4 parallel workers
Sum using parallel workers = 5000000050000000
Time taken for sum using parallel workers = 30.539467ms
All workers finished
https://ideone.com/RT0W5s
language:
Go (go 1.12.1)
created:
18 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!