Golang program to compute all prime numbers up to a given number using concurrency

In this Go language article, we will write programs to compute all prime numbers up to a given number using concurrent execution. Concurrent execution is the process of executing multiple tasks simultaneously. In Golang, go routines and channels are used to create concurrent programs.

Go routines are lightweight threads which are managed by the Go runtime and channels help in the communication between Go routines without any conflicts.

Syntax

func make ([] type, size, capacity)

The make function in go language is used to create an array/map it accepts the type of variable to be created, its size and capacity as arguments.

func range(variable)

The range function is used to iterate over any data type. To use this, we first have to write the range keyword followed by the data type to which we want to iterate and as a result the loop will iterate till the last element of the variable.

Algorithm

• This program imports main, fmt and sync package in the program

• Create a main function

• In the main set the range with the variable limit up to which the prime numbers will be calculated

• Then, create a channel named primes using make function which will obtain the prime numbers

• In this step, create a Wait Group wg so that all go routines finish before exiting the main function

• Then, start the go routine by calling the generate Primes function

• Here, pass the limit, primes channel, and the wg as arguments

• Start another go routine to print the prime numbers by calling the print Primes function

• Here, pass the primes channel and the Wait Group as arguments

• Then, use wait function to wait for all go routines to finish

• In this step, create a function generate Primes to generate prime numbers up to a given limit

• In this function, send the initial prime numbers 2 and 3 to the primes channel. Then, it iterates from 5 up to the limit in steps of 2

• In each iteration, it checks for primality by iterating from 3 up to the square root of the number

• If the number is divisible by any of these divisors, it's not a prime, and is Prime is set to false. Otherwise, it remains true

• If the number is prime it is sent to the primes channel

• Create print Primes function to receives the prime numbers from the primes channel and print them

• Once all numbers are printed, it calls wg.Done() to signal the Wait Group that it has finished printing

• The program ends after all go routines finish

Example

In this example, we will write a Golang program to compute all prime numbers using go routines and channels so that concurrent execution takes place.

package main
import (
	"fmt"
	"sync"
)
func main() {	
	limit := 100
	primes := make(chan int)
	var wg sync.WaitGroup

	wg.Add(1)
	go generatePrimes(limit, primes, &wg)

	wg.Add(1)
	go printPrimes(primes, &wg)
	wg.Wait()
}
func generatePrimes(limit int, primes chan<- int, wg *sync.WaitGroup) {
	defer close(primes)
	defer wg.Done()
	primes <- 2
	primes <- 3
	for num := 5; num <= limit; num += 2 {
		isPrime := true		
		for i := 3; i*i <= num; i += 2 {
			if num%i == 0 {
				isPrime = false
				break
			}
		}
		if isPrime {
			primes <- num
		}
	}
}
func printPrimes(primes <-chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("The prime numbers till the rage of 100 are:")

	for prime := range primes {
		fmt.Println(prime)
	}
}

Output

The prime numbers till the rage of 100 are:
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

Conclusion

We compiled and executed the program of computing prime numbers up to a given number with the help of an example in which we used go routines and channels for concurrent implementation.