Tutorial9 - Channels

Author: Shikha-code36

README.md

@@ -49,4 +49,5 @@ 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)
+- [x] [Concurrency(Goroutines)](tutorial8)
+- [x] [Channels)](tutorial9)

tutorial9/README.md

@@ -0,0 +1,65 @@
+# Go Channels 
+
+This Go program demonstrates the use of channels for communication between goroutines.
+
+## Key Concepts
+
+### Channels
+
+Channels are a typed conduit through which you can send and receive values with the channel operator, `<-`.
+
+```go
+var c = make(chan int) //this channel can only hold a single int value
+c <- 1                 // adding value to this channel
+var i = <-c            // retrieve the value from the channel now c will be empty and i = 1
+fmt.Println(i)
+```
+
+If we run the above code directly, it will give a deadlock error. This is because the main goroutine is trying to receive a value from the channel, but there is no other goroutine available to send a value.
+
+### Buffered Channels
+
+Buffered channels can hold more than one value before they block. The capacity is passed as the second argument to `make`.
+
+```go
+var c = make(chan int, 5) // this channel can hold up to 5 int values
+```
+
+### Goroutines and Channels
+
+Goroutines can send values into a channel, and other goroutines can receive those values.
+
+```go
+func main() {
+    var c = make(chan int, 5)
+    go process2(c)
+    fmt.Println(<-c)
+    for i:= range c{
+        fmt.Println(i)
+        time.Sleep(time.Second+1)
+    }
+}
+```
+
+In the `main` function, we create a buffered channel `c` and spawn a goroutine `process2(c)`. We then receive a value from the channel and print it. We also range over the channel to receive all remaining values.
+
+### Closing Channels
+
+Senders can close a channel to indicate that no more values will be sent. Receivers can test whether a channel has been closed by assigning a second parameter to the receive expression.
+
+```go
+func process2(c chan int){
+    defer close(c)
+    for i:=0; i<5; i++{
+        c <- i
+    }
+    fmt.Println("Exiting Process")
+}
+```
+
+In the `process2` function, we defer the call to `close(c)` to ensure that the channel will be closed once all values have been sent. We then send five values into the channel and print a message indicating that the process is exiting.
+
+
+### Checkout the code
+
+- [main.go](main.go)

tutorial9/main.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+var MAX_CHICKEN_PRICE float32 = 5
+var MAX_TOFU_PRICE float32 = 3
+
+func main(){
+	var chickenChannel = make(chan string)
+	var tofuChannel = make(chan string)
+	var websites = []string{"swiggy", "zomato", "eatclub"}
+	for i:= range websites{
+		go checkChickenPrices(websites[i], chickenChannel)
+		go checkTofuPrices(websites[i], tofuChannel)
+	}
+	sendMessage(chickenChannel, tofuChannel)
+}
+
+func checkChickenPrices(website string, chickenChannel chan string){
+	for {
+		time.Sleep(time.Second+1)
+		var chickenPrice = rand.Float32()*20
+		if chickenPrice<=MAX_CHICKEN_PRICE{
+			chickenChannel <- website
+			break
+		}
+	}
+}
+
+func checkTofuPrices(website string, tofuChannel chan string){
+	for {
+		time.Sleep(time.Second+1)
+		var tofuPrice = rand.Float32()*20
+		if tofuPrice<=MAX_TOFU_PRICE{
+			tofuChannel <- website
+			break
+		}
+	}
+}
+
+func sendMessage(chickenChannel chan string, tofuChannel chan string){
+	select{
+	case website := <-chickenChannel:
+		fmt.Printf("\nText Sent: Found deal on chicken at %v.", website)
+	case website := <-tofuChannel:
+		fmt.Printf("Email Sent: Found deal on tofu at %v.", website)
+	}
+}
+
+
+
+// func main() {
+// 	//var c = make(chan int)
+// 	var c = make(chan int, 5) //by adding this process function will run immediately but main function will take time
+// 	//go process(c)
+// 	go process2(c)
+// 	fmt.Println(<-c)
+// 	for i:= range c{
+// 		fmt.Println(i)
+// 		time.Sleep(time.Second+1)
+// 	}
+// }
+
+// // func process(c chan int){
+// // 	c <- 123
+// // }
+
+// func process2(c chan int){
+// 	defer close(c)
+// 	for i:=0; i<5; i++{
+// 		c <- i
+// 	}
+// 	fmt.Println("Exiting Process")
+// }
+
+/*
+var c = make(chan int) //this channel can only hold a single int value
+c <- 1                 // adding value to this channel
+var i = <-c            // retrieve the value from the channel now c will be empty and i = 1
+fmt.Println(i)
+
+if we run the above code direclty it will give deadlock error
+*/