What are Goroutines

What are Goroutines?

Go में Goroutines एक तरीके के lightweight threads होते हैं। अगर आपको एक साथ (concurrently) multiple tasks को efficiently run करना है, तो आप Goroutines का इस्तेमाल करते हैं। यह main thread से अलग काम करते हैं और independently execute होते हैं।

Think of goroutines as helpers जो आपके लिए अलग-अलग कामों को parallel में कर सकते हैं।

Real-Life Example to Understand Goroutines

Imagine कि आप और आपके दोस्त एक dinner की तैयारी कर रहे हैं:

• आप रोटियां बना रहे हैं, और
• आपका दोस्त सब्जी बना रहा है।

दोनों काम parallel में हो रहे हैं। ऐसा ही Goroutines में होता है, जहां multiple tasks एक साथ execute होते हैं, जिससे आपका काम जल्दी हो जाता है।

How to Start a Goroutine?

Goroutine को start करने के लिए आपको go keyword का उपयोग करना होता है। जब आप go keyword किसी function call से पहले लिखते हैं, तो वह function एक अलग goroutine में execute होने लगता है।

Basic Example of a Goroutine

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(1 * time.Second) // 1 second का pause
    }
}

func main() {
    go printNumbers() // Goroutine start

    // Main function runs concurrently
    fmt.Println("Main function is running")

    // Wait for goroutine to finish
    time.Sleep(6 * time.Second)
    fmt.Println("Main function finished")
}

Explanation:

• go printNumbers(): यह function अलग goroutine में run हो रहा है। इसका मतलब यह है कि यह independently execute होगा और आपका main function उसी समय parallel में काम करता रहेगा।
• time.Sleep(6 * time.Second): यह main function को थोड़ी देर रोकता है ताकि goroutine अपना काम पूरा कर सके।

Output:

Main function is running
1
2
3
4
5
Main function finished

Why Use Goroutines?

Goroutines का सबसे बड़ा फायदा यह है कि आप concurrency handle कर सकते हैं, यानी आप एक साथ multiple कामों को efficiently run कर सकते हैं। यह खासकर तब मदद करता है जब:

• आपको multiple tasks को parallel में चलाना हो।
• आपको time-consuming tasks को background में run करना हो, जैसे कि file downloads, data processing, या network requests।

How Goroutines Are Different from Threads?

• Goroutines बहुत lightweight होती हैं, जबकि traditional threads ज्यादा memory consume करती हैं।
• आप हजारों goroutines को एक ही program में efficiently run कर सकते हैं।
• Goroutines को Go scheduler manage करता है, जो उन्हें efficiently CPU cores पर run करवाता है।

Communication Between Goroutines (Using Channels)

Goroutines के बीच communication के लिए आप channels का इस्तेमाल करते हैं। Channels एक pipeline की तरह काम करते हैं जिससे आप data को एक goroutine से दूसरे में भेज सकते हैं।

Example: Two Goroutines Working Together (Cooking Analogy)

package main

import (
    "fmt"
    "time"
)

func cook(veggieChannel chan string) {
    veggies := []string{"Carrot", "Potato", "Onion"}
    for _, veggie := range veggies {
        fmt.Println("Cooking:", veggie)
        veggieChannel <- veggie // Send veggie to the channel
        time.Sleep(1 * time.Second)
    }
    close(veggieChannel) // Close the channel when done
}

func eat(veggieChannel chan string) {
    for veggie := range veggieChannel {
        fmt.Println("Eating:", veggie)
        time.Sleep(2 * time.Second)
    }
}

func main() {
    veggieChannel := make(chan string) // Channel for veggies

    go cook(veggieChannel) // Start cooking in one goroutine
    go eat(veggieChannel)  // Start eating in another goroutine

    time.Sleep(10 * time.Second) // Give enough time for both goroutines
}

Explanation:

• cook(): यह goroutine सब्जियां बना रही है और उन्हें channel के जरिए भेज रही है।
• eat(): यह goroutine सब्जियों को receive करके उन्हें "खा" रही है।
• Channels: Channels का उपयोग दोनों goroutines के बीच synchronization और data sharing के लिए किया गया है।

Output:

Cooking: Carrot
Eating: Carrot
Cooking: Potato
Eating: Potato
Cooking: Onion
Eating: Onion

Real-Life Uses of Goroutines

• Web Servers: Concurrent requests को efficiently handle करने के लिए goroutines का उपयोग होता है।
• Background Tasks: Time-consuming tasks जैसे कि file downloads को background में run करने के लिए goroutines का उपयोग किया जाता है।
• Multiple Task Execution: जैसे game development में player movement और enemies को manage करने के लिए अलग-अलग goroutines का उपयोग किया जा सकता है।

Waiting for Goroutines to Finish

कई बार आपको ensure करना होता है कि आपके goroutines पूरा execute हो चुके हैं। इसके लिए आप sync.WaitGroup का use कर सकते हैं।

Example: Using WaitGroup to Wait for Goroutines

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // Notify WaitGroup when this goroutine finishes
    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 <= 3; i++ {
        wg.Add(1) // Increment the WaitGroup counter
        go worker(i, &wg) // Start a new goroutine
    }

    wg.Wait() // Wait for all goroutines to finish
    fmt.Println("All workers finished")
}

Explanation:

• sync.WaitGroup: यह tool main function को तब तक रोक कर रखता है जब तक कि सभी goroutines finish नहीं हो जातीं।
• wg.Add(1): हर बार जब एक नया goroutine start होता है, WaitGroup की count बढ़ाई जाती है।
• wg.Done(): जब goroutine अपना काम पूरा कर लेता है, तो वह count को decrease कर देता है।
• wg.Wait(): यह तब तक wait करता है जब तक कि सभी goroutines finish नहीं हो जाते।

Output:

Worker 1 starting
Worker 2 starting
Worker 3 starting
Worker 1 done
Worker 2 done
Worker 3 done
All workers finished

Goroutines with Anonymous Functions

आप Goroutines को anonymous functions के साथ भी चला सकते हैं। यह बहुत convenient होता है जब आपको छोटे tasks run करने होते हैं।

Example: Goroutines with Anonymous Functions

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        fmt.Println("Anonymous goroutine is running")
        time.Sleep(2 * time.Second)
        fmt.Println("Anonymous goroutine finished")
    }()

    time.Sleep(3 * time.Second) // Wait for goroutine to finish
    fmt.Println("Main function finished")
}

Explanation: Anonymous function का उपयोग करके आप छोटे tasks को goroutines में आसानी से run कर सकते हैं।

Output:

Anonymous goroutine is running
Anonymous goroutine finished
Main function finished

Summary

• Goroutines: Go में lightweight threads होते हैं, जिन्हें efficiently एक साथ multiple tasks execute करने के लिए use किया जाता है।
• Concurrency: Goroutines को इस्तेमाल करके आप एक साथ कई काम कर सकते हैं, जिससे आपका program तेज और efficient बनता है।
• Communication via Channels: Goroutines के बीच data को safely share करने के लिए channels का इस्तेमाल किया जाता है।
• WaitGroup: Multiple goroutines को manage और synchronize करने के लिए WaitGroup का उपयोग किया जाता है।
• Real-Life Use: Web servers, background tasks, और data processing जैसे scenarios में goroutines बहुत useful होते हैं।

Previous