Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
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.
134 Views
