Tutorial8 - Concurrency(Goroutines)

Author: Shikha-code36

README.md

@@ -49,3 +49,4 @@ go run tutorial1/main.go
 - [x] [Strings, Runes, and UTF-8 Encoding](tutorial5)
 - [x] [Structs and Interfaces](tutorial6)
 - [x] [Pointers](tutorial7)
+- [x] [Concurrency(Goroutines)](tutorial8)

tutorial8/README.md

@@ -0,0 +1,66 @@
+## Concurrency(Goroutines) in GO
+
+Concurrency is the execution of multiple instruction sequences at the same time. In Go, concurrency is achieved using goroutines. A goroutine is a lightweight thread of execution managed by the Go runtime. You can launch a function as a goroutine by prefixing the function call with the `go` keyword.
+
+```go
+go dbCall(i)
+```
+
+However, if we run the code like this, it will feel like nothing happened. Our program spawns these tasks in the background, doesn't wait for them to finish, and then exits the program before they are complete. This is where wait groups come in.
+
+## WaitGroup
+
+A WaitGroup is used to wait for a collection of goroutines to finish executing. The main goroutine calls `Add` to set the number of goroutines to wait for. Then each of the goroutines runs and calls `Done` when finished. At the same time, `Wait` can be used to block until all goroutines have finished.
+
+```go
+var wg = sync.WaitGroup{}
+
+func main(){
+    for i:=0; i<len(dbData); i++{
+        wg.Add(1)
+        go dbCall(i)
+    }
+    wg.Wait()
+}
+```
+
+## Mutex
+
+A Mutex, or a mutual exclusion lock, is a synchronization primitive that can be used to protect shared data from being concurrently accessed by multiple goroutines. In Go, `sync.Mutex` is used for this purpose.
+
+```go
+var m = sync.Mutex{}
+
+func save(result string){
+    m.Lock()
+    results = append(results, result)
+    m.Unlock()
+}
+```
+
+However, one drawback of a mutex is that it completely locks out other goroutines from accessing a result slice. This is where `sync.RWMutex` comes in.
+
+## RWMutex
+
+`sync.RWMutex` is a reader/writer mutual exclusion lock. The lock can be held by an arbitrary number of readers or a single writer. It has `RLock` and `RUnlock` methods for reading, and `Lock` and `Unlock` methods for writing.
+
+```go
+var m = sync.RWMutex{}
+
+func save(result string){
+    m.Lock()
+    results = append(results, result)
+    m.Unlock()
+}
+
+func log(){
+    m.RLock()
+    fmt.Printf("\nThe current results are: %v", results)
+    m.RUnlock()
+}
+```
+
+### Checkout the code
+
+ - [main.go](main.go)
+

tutorial8/main.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"fmt"
+	"time"
+	"sync"
+)
+
+//var m = sync.Mutex{} // we can use the mutex to control the writing to or slice in a way that makes it safe in a concurrent program
+var m = sync.RWMutex{}
+var wg = sync.WaitGroup{}
+
+var dbData = []string{"id1", "id2", "id3", "id4", "id5"}
+var results = []string{}
+
+func main(){
+	t0 := time.Now()
+	for i:=0; i<len(dbData); i++{
+		wg.Add(1) //whenever we spawn a new go routine need to make sure to add 1 to the counter
+		go dbCall(i)
+	}
+	wg.Wait()
+	fmt.Printf("\nTotal execution time: %v", time.Since(t0))
+	fmt.Printf("\nThe results are %v",results)
+}
+
+func dbCall(i int){
+	// Simulate DB call delay
+	var delay float32 = 2000
+	time.Sleep(time.Duration(delay)*time.Millisecond)
+	fmt.Println("\nThe result from the database is:", dbData[i])
+	// initial code during mutex
+	// m.Lock()
+	// results = append(results, dbData[i])
+	// m.Unlock()
+	save(dbData[i])
+	log()
+	wg.Done()
+}
+
+func save(result string){
+	m.Lock()
+	results = append(results, result)
+	m.Unlock()
+}
+
+func log(){
+	m.RLock()
+	fmt.Printf("\nThe current results are: %v", results)
+	m.RUnlock()
+}
+// one drawback of mutex is it completely locks out othe goroutines to accessing a result slice
+
+/*
+func main(){
+	t0 := time.Now()
+	for i:=0; i<len(dbData); i++{
+		dbCall(i)
+	}
+	fmt.Printf("\nTotal execution time: %v", time.Since(t0))
+}
+
+func dbCall(i int){
+	// Simulate DB call delay
+	var delay float32 = rand.Float32()*2000
+	time.Sleep(time.Duration(delay)*time.Millisecond)
+	fmt.Println("The result from the database is:", dbData[i])
+}
+
+this gave output 
+The result from the database is: id1
+The result from the database is: id2
+The result from the database is: id3
+The result from the database is: id4
+The result from the database is: id5
+
+Total execution time: 4.0624966s
+
+Another way to do this good way to let these db calls run concurrently to do this we use 
+'go' keyword infront of the function you want to run concurrently
+
+go dbCall(i)
+
+if we run code like this it will feel like that nothing happened
+so our program spawn these tasks in the background, didn't wait for them to finish
+and then exited the program before they were complete
+
+we need a way for our program to wait until all tasks completed and continue on to the rest of the code
+this where wait groups comes in, which can be imported through sync package
+*/