Added go-routines and select

Author: erdemkosk

README.md

@@ -0,0 +1,37 @@
+
+# Go Concurrency Patterns 
+
+Concurrency Patterns about go are collected in this repo. For **learning purposes**
+
+
+## Appendix
+
+Concurrency refers to the ability of a software system to handle **multiple tasks** or **processes at the same time**. It allows programs to execute several computations simultaneously, making efficient use of available resources.
+
+In software, concurrency doesn’t necessarily mean true simultaneous execution on multiple cores. Instead, it involves managing multiple tasks by **interleaving their execution**, giving the **illusion of parallelism**. This is typically achieved through mechanisms like threading, asynchronous programming, or the use of concurrent constructs like **goroutines** in Go or **async/await** in languages like JavaScript.
+
+Concurrency **enables applications to remain responsive by managing various operations concurrently**, such as handling user input, processing data, or performing I/O operations, without waiting for one task to finish before starting another. It's essential in designing systems that can efficiently utilize available resources and improve overall performance.
+
+
+## Lessons Learned
+
+#### Goroutine 
+A goroutine is a lightweight thread of execution in Go. It's a concurrent unit of work that can be executed independently within a Go program. **Goroutines are managed by the Go runtime** and allow multiple functions to run concurrently. They're different from threads in other programming languages in that they're managed at a higher level by the Go runtime, enabling efficient scheduling and utilization of resources. Goroutines are relatively cheap to create and are fundamental to building **concurrent and scalable applications** in Go.
+
+
+#### Select
+The select statement is used to listen for data coming from multiple channels concurrently, but the crucial aspect is the concurrent (or asynchronous) nature. Especially when multiple tasks are being performed, using the select statement allows simultaneous access to data from channels and optimizes the processing time of the program.
+
+For instance, when waiting for data from the network or different threads of execution, it enables the main thread to continue doing other tasks while waiting for data from channels. **Instead of waiting idly until data arrives** from any channel, **select concurrently monitors multiple channels** and acts accordingly when data arrives.
+
+**The main thread waits until data is received from** any of the channels being listened to with the select statement. However, it can also continue with other tasks, execute other threads of execution, or perform different operations.
+
+This feature allows programs to monitor and manage various tasks concurrently, preventing the program from blocking in unexpected situations. The use of select is highly beneficial in scenarios involving asynchronous operations or listening for data from various sources.
+
+#### Buffered vs Unbuffered Channels
+#### The Done Channel
+#### Pipeline
+
+
+
+

go.mod

@@ -0,0 +1,3 @@
+module github.com/erdemkosk/go-concurrency
+
+go 1.21.4

goroutines.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+// A goroutine is a lightweight thread of execution in Go. It's a concurrent unit of work that can be executed independently within a Go program.
+//  Goroutines are managed by the Go runtime and allow multiple functions to run concurrently.
+//  They're different from threads in other programming languages in that they're managed at a higher level by the Go runtime, enabling efficient scheduling and utilization of resources.
+//  Goroutines are relatively cheap to create and are fundamental to building concurrent and scalable applications in Go.
+
+func GoRoutinesExample() {
+	fmt.Println("--------------------------")
+	channel1 := make(chan string)
+	channel2 := make(chan string)
+
+	go goRoutine1(channel1)
+	go goRoutine2(channel2)
+
+	msg1 := <-channel1
+	msg2 := <-channel2
+
+	fmt.Println(msg1)
+	fmt.Println(msg2)
+
+	fmt.Println("Hello from GoRoutines!")
+}
+
+func goRoutine1(c chan string) {
+	time.Sleep(1 * time.Second)
+	c <- "1"
+}
+
+func goRoutine2(c chan string) {
+	time.Sleep(1 * time.Second)
+	c <- "2"
+}

main.go

@@ -0,0 +1,6 @@
+package main
+
+func main() {
+	GoRoutinesExample()
+	SelectExample()
+}

select.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+// The select statement is used to listen for data coming from multiple channels concurrently, but the crucial aspect is the concurrent (or asynchronous) nature.
+// Especially when multiple tasks are being performed, using the select statement allows simultaneous access to data from channels and optimizes the processing time of the program.
+
+// For instance, when waiting for data from the network or different threads of execution, it enables the main thread to continue doing other tasks while waiting for data from channels.
+//  Instead of waiting idly until data arrives from any channel, select concurrently monitors multiple channels and acts accordingly when data arrives.
+
+// The main thread waits until data is received from any of the channels being listened to with the select statement. However, it can also continue with other tasks,
+//  execute other threads of execution, or perform different operations.
+
+// This feature allows programs to monitor and manage various tasks concurrently, preventing the program from blocking in unexpected situations.
+// The use of select is highly beneficial in scenarios involving asynchronous operations or listening for data from various sources.
+
+func SelectExample() {
+	fmt.Println("--------------------------")
+	channel3 := make(chan string)
+	channel4 := make(chan string)
+
+	go goRoutine3(channel3)
+	go goRoutine4(channel4)
+
+	select {
+	case msg1 := <-channel3:
+		fmt.Println("Received from Channel 3:", msg1)
+	case msg2 := <-channel4:
+		fmt.Println("Received from Channel 4:", msg2)
+	}
+
+	fmt.Println("Hello From Select!")
+}
+
+func goRoutine3(c chan string) {
+	time.Sleep(1 * time.Second)
+	c <- "3"
+}
+
+func goRoutine4(c chan string) {
+	time.Sleep(1 * time.Second)
+	c <- "4"
+}