[ADD] waitgroups, rate limiting, atomic counters

Author: ineelhere

codes/atomic-counters.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+)
+
+func main() {
+
+	var ops atomic.Uint64
+
+	var wg sync.WaitGroup
+
+	for i := 0; i < 50; i++ {
+		wg.Add(1)
+
+		go func() {
+			for c := 0; c < 1000; c++ {
+
+				ops.Add(1)
+			}
+
+			wg.Done()
+		}()
+	}
+
+	wg.Wait()
+
+	fmt.Println("ops:", ops.Load())
+}

codes/rate-limiting.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+
+	requests := make(chan int, 5)
+	for i := 1; i <= 5; i++ {
+		requests <- i
+	}
+	close(requests)
+
+	limiter := time.Tick(200 * time.Millisecond)
+
+	for req := range requests {
+		<-limiter
+		fmt.Println("request", req, time.Now())
+	}
+
+	burstyLimiter := make(chan time.Time, 3)
+
+	for i := 0; i < 3; i++ {
+		burstyLimiter <- time.Now()
+	}
+
+	go func() {
+		for t := range time.Tick(200 * time.Millisecond) {
+			burstyLimiter <- t
+		}
+	}()
+
+	burstyRequests := make(chan int, 5)
+	for i := 1; i <= 5; i++ {
+		burstyRequests <- i
+	}
+	close(burstyRequests)
+	for req := range burstyRequests {
+		<-burstyLimiter
+		fmt.Println("request", req, time.Now())
+	}
+}

codes/waitgroups.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+func worker(id int) {
+	fmt.Printf("Worker %d starting\n", id)
+
+	time.Sleep(time.Second)
+	fmt.Printf("Worker %d done\n", id)
+}
+
+func main() {
+
+	var wg sync.WaitGroup
+
+	for i := 1; i <= 5; i++ {
+		wg.Add(1)
+
+		i := i
+
+		go func() {
+			defer wg.Done()
+			worker(i)
+		}()
+	}
+
+	wg.Wait()
+
+}

documentation/38-wait-groups.md

@@ -0,0 +1,77 @@
+This Go code demonstrates the use of the `sync.WaitGroup` to wait for a collection of goroutines to finish their execution. Let's go through it with inline comments:
+
+```go
+package main
+
+import (
+    "fmt"
+    "sync"
+    "time"
+)
+
+// worker function represents a worker that performs some work
+func worker(id int) {
+    fmt.Printf("Worker %d starting\n", id)
+
+    // Simulate work by sleeping for one second
+    time.Sleep(time.Second)
+
+    fmt.Printf("Worker %d done\n", id)
+}
+
+func main() {
+    // Creating a WaitGroup to wait for all goroutines to finish
+    var wg sync.WaitGroup
+
+    for i := 1; i <= 5; i++ {
+        // Incrementing the WaitGroup counter for each goroutine
+        wg.Add(1)
+
+        // Creating a local variable 'i' to capture the current value
+        i := i
+
+        // Launching a goroutine for each worker
+        go func() {
+            // Decrementing the WaitGroup counter when the goroutine completes
+            defer wg.Done()
+            worker(i)
+        }()
+    }
+
+    // Waiting for all goroutines to finish
+    wg.Wait()
+}
+```
+### Output
+```
+Worker 2 starting
+Worker 3 starting
+Worker 5 starting
+Worker 4 starting
+Worker 1 starting
+Worker 1 done
+Worker 4 done
+Worker 5 done
+Worker 2 done
+Worker 3 done
+```
+
+Explanation:
+
+1. `package main`: Indicates that this Go file belongs to the main executable package.
+
+2. `import (...)`: Imports necessary packages, including "fmt" for formatting and printing, "sync" for synchronization, and "time" for handling time-related operations.
+
+3. `func worker(id int) { ... }`: Defines a worker function that simulates work by sleeping for one second and prints messages.
+
+4. `var wg sync.WaitGroup`: Creates a `sync.WaitGroup` variable named 'wg' to wait for a collection of goroutines to finish.
+
+5. `wg.Add(1)`: Increments the WaitGroup counter for each goroutine to indicate that a new goroutine is starting.
+
+6. `i := i`: Creates a local variable 'i' to capture the current value of the loop variable, preventing its value from changing in the closure.
+
+7. `go func() { ... }()`: Launches a goroutine for each worker. The `defer wg.Done()` statement is used to decrement the WaitGroup counter when the goroutine completes.
+
+8. `wg.Wait()`: Waits for all goroutines to finish by blocking until the WaitGroup counter becomes zero.
+
+This code demonstrates how to use a `sync.WaitGroup` to coordinate the execution of multiple goroutines. Each worker is launched as a goroutine, and the WaitGroup is used to wait for all workers to complete their work before proceeding further in the main function. The use of a local variable inside the loop ensures that each goroutine captures the correct value of 'i'.

documentation/39-rate-limiting.md

@@ -0,0 +1,119 @@
+This Go code demonstrates the use of rate limiting with time. Tick and channels to control the frequency of requests. 
+
+Let's go through it with inline comments:
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	// Creating a buffered channel 'requests' for sending requests
+	requests := make(chan int, 5)
+
+	// Sending 5 requests to the 'requests' channel
+	for i := 1; i <= 5; i++ {
+		requests <- i
+	}
+	close(requests)
+
+	// Creating a rate limiter with a tick of 200 milliseconds
+	limiter := time.Tick(200 * time.Millisecond)
+
+	// Processing requests with the rate limiter
+	for req := range requests {
+		<-limiter
+		fmt.Println("request", req, time.Now())
+	}
+
+	// Creating a buffered channel 'burstyLimiter' with a capacity of 3
+	burstyLimiter := make(chan time.Time, 3)
+
+	// Initializing 'burstyLimiter' with three time values
+	for i := 0; i < 3; i++ {
+		burstyLimiter <- time.Now()
+	}
+
+	// Launching a goroutine to refill 'burstyLimiter' every 200 milliseconds
+	go func() {
+		for t := range time.Tick(200 * time.Millisecond) {
+			burstyLimiter <- t
+		}
+	}()
+
+	// Creating a buffered channel 'burstyRequests' for sending bursty requests
+	burstyRequests := make(chan int, 5)
+
+	// Sending 5 bursty requests to 'burstyRequests' channel
+	for i := 1; i <= 5; i++ {
+		burstyRequests <- i
+	}
+	close(burstyRequests)
+
+	// Processing bursty requests with the bursty rate limiter
+	for req := range burstyRequests {
+		<-burstyLimiter
+		fmt.Println("request", req, time.Now())
+	}
+}
+```
+### Output
+```
+request 1 2024-01-23 19:12:37.8840836 +0530 IST m=+0.210007101
+request 2 2024-01-23 19:12:38.0886902 +0530 IST m=+0.414613701
+request 3 2024-01-23 19:12:38.2896166 +0530 IST m=+0.615540101
+request 4 2024-01-23 19:12:38.4904667 +0530 IST m=+0.816390201
+request 5 2024-01-23 19:12:38.6761374 +0530 IST m=+1.002060901
+request 1 2024-01-23 19:12:38.6763013 +0530 IST m=+1.002224801
+request 2 2024-01-23 19:12:38.6768092 +0530 IST m=+1.002732701
+request 3 2024-01-23 19:12:38.6768092 +0530 IST m=+1.002732701
+request 4 2024-01-23 19:12:38.8792461 +0530 IST m=+1.205169601
+request 5 2024-01-23 19:12:39.0807175 +0530 IST m=+1.406641001
+```
+Explanation:
+
+1. `package main`: Indicates that this Go file belongs to the main executable package.
+
+2. `import (...)`: Imports necessary packages, including "fmt" for formatting and printing, and "time" for handling time-related operations.
+
+3. `requests := make(chan int, 5)`: Creates a buffered channel 'requests' for sending requests with a capacity of 5.
+
+4. Sending 5 requests to the 'requests' channel, and then closing the channel to indicate that no more requests will be sent.
+
+5. `limiter := time.Tick(200 * time.Millisecond)`: Creates a rate limiter using `time.Tick` with a tick interval of 200 milliseconds.
+
+6. Processing requests with the rate limiter. Each request waits for the limiter to allow it before being processed.
+
+7. Creating a buffered channel 'burstyLimiter' with a capacity of 3.
+
+8. Initializing 'burstyLimiter' with three time values to allow for an initial burst of requests.
+
+9. Launching a goroutine to refill 'burstyLimiter' every 200 milliseconds, creating a bursty rate limiter.
+
+10. `burstyRequests := make(chan int, 5)`: Creates a buffered channel 'burstyRequests' for sending bursty requests with a capacity of 5.
+
+11. Sending 5 bursty requests to 'burstyRequests' channel and then closing the channel.
+
+12. Processing bursty requests with the bursty rate limiter. The initial burst is allowed due to the buffered channel 'burstyLimiter'.
+
+In summary, this code demonstrates two scenarios of rate limiting using channels and `time.Tick`. The first scenario demonstrates regular rate limiting, while the second scenario introduces a bursty rate limiter allowing an initial burst of requests before settling into a regular rate.
+
+### Further Explanation
+Rate limiting is a technique used to control the rate at which events, such as requests or operations, are allowed to occur. It helps prevent resource exhaustion, manage traffic, and maintain system stability. In the provided Go code, two examples of rate limiting are demonstrated: regular rate limiting and bursty rate limiting.
+
+1. **Regular Rate Limiting:**
+   - The first part of the code uses a simple rate limiter created with `time.Tick(200 * time.Millisecond)`. This creates a channel that ticks every 200 milliseconds. Each request is processed only when it receives a tick from this channel.
+   - This ensures that requests are processed at a regular interval, limiting the rate at which they can occur. If a request arrives before the next tick, it will wait for the next tick to proceed.
+   - This is useful to ensure a steady flow of requests and prevent a sudden surge that could overload the system.
+
+2. **Bursty Rate Limiting:**
+   - The second part of the code introduces a bursty rate limiter, allowing an initial burst of requests to be processed more rapidly.
+   - The `burstyLimiter` channel is buffered with a capacity of 3, allowing three requests to be processed without waiting for the tick.
+   - The channel is initially filled with three time values, allowing an immediate burst of requests.
+   - A goroutine is launched to continuously refill the channel with time values every 200 milliseconds, creating a regular tick for subsequent requests.
+   - This allows for a burst of requests initially, followed by a regular rate of requests, combining the benefits of burstiness and regular rate limiting.
+
+In both scenarios, rate limiting is achieved by using channels and `time.Tick`. The rate limiter allows a controlled number of events to occur within a specified time interval, preventing a flood of requests and ensuring a more controlled and predictable behavior for the system. It's a common technique used in systems to prevent abuse, manage resources, and maintain overall stability.

documentation/40-atomic-conters.md

@@ -0,0 +1,78 @@
+This Go code demonstrates the use of the `sync/atomic` package and the `atomic.Uint64` type to perform atomic operations on a `uint64` variable. Let's go through the code with inline comments:
+
+```go
+package main
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+)
+
+func main() {
+	// Creating an atomic.Uint64 variable named 'ops'
+	var ops atomic.Uint64
+
+	// Creating a WaitGroup to wait for all goroutines to finish
+	var wg sync.WaitGroup
+
+	// Launching 50 goroutines
+	for i := 0; i < 50; i++ {
+		// Incrementing the WaitGroup counter for each goroutine
+		wg.Add(1)
+
+		// Launching a goroutine
+		go func() {
+			// Performing 1000 atomic increments on the 'ops' variable
+			for c := 0; c < 1000; c++ {
+				ops.Add(1)
+			}
+
+			// Decrementing the WaitGroup counter when the goroutine completes
+			wg.Done()
+		}()
+	}
+
+	// Waiting for all goroutines to finish
+	wg.Wait()
+
+	// Loading the final value of 'ops' using ops.Load()
+	fmt.Println("ops:", ops.Load())
+}
+```
+
+Explanation:
+
+1. `package main`: Indicates that this Go file belongs to the main executable package.
+
+2. `import (...)`: Imports necessary packages, including "fmt" for formatting and printing, "sync" for synchronization, and "sync/atomic" for atomic operations.
+
+3. `var ops atomic.Uint64`: Creates an atomic `uint64` variable named 'ops' using `atomic.Uint64`.
+
+4. `var wg sync.WaitGroup`: Creates a `sync.WaitGroup` variable named 'wg' to wait for all goroutines to finish.
+
+5. Launching 50 goroutines, each performing 1000 atomic increments on the 'ops' variable.
+
+6. `ops.Add(1)`: Atomically increments the value of 'ops' by 1.
+
+7. `wg.Add(1)`: Increments the WaitGroup counter for each goroutine.
+
+8. `wg.Done()`: Decrements the WaitGroup counter when a goroutine completes.
+
+9. `wg.Wait()`: Waits for all goroutines to finish.
+
+10. `ops.Load()`: Loads the final value of 'ops' atomically.
+
+11. Printing the final value of 'ops'.
+
+In summary, this code demonstrates the use of the `sync/atomic` package to perform atomic operations on a `uint64` variable (`ops`). The `atomic.Uint64` type provides atomic methods for performing operations like increments without the need for locks, ensuring safe concurrent access to the variable. The final value of 'ops' represents the total number of increments performed across all goroutines.
+
+### Further Explanation
+
+In concurrent programming, the term "atomic" refers to an operation that is executed as a single, indivisible unit, without the possibility of interruption or interference by other concurrent operations. In the context of the Go programming language and its `sync/atomic` package, "atomic" operations are designed to be thread-safe and avoid race conditions.
+
+In simpler terms, when an operation is atomic, it is guaranteed to be completed without being interrupted by other parallel operations. This is particularly crucial in concurrent or multithreaded programs where multiple threads or goroutines may be accessing shared data simultaneously. Without atomicity, there is a risk of data corruption or unexpected behavior due to interference between concurrent operations.
+
+The `sync/atomic` package in Go provides atomic types and functions for performing atomic operations on variables. For example, `atomic.AddUint64` increments a `uint64` variable in an atomic manner, ensuring that the operation is completed without interruption and without the need for explicit locks.
+
+In the provided code example, `atomic.Uint64` is used to create an atomic `uint64` variable named 'ops'. The `Add(1)` operation on 'ops' is atomic, meaning that each increment is guaranteed to complete as a single, uninterrupted operation, even when performed concurrently by multiple goroutines. This helps prevent data corruption and ensures the accuracy of the final result when multiple goroutines are involved in incrementing the variable concurrently.