तपाईं `sync` प्याकेज कहिले चयन गर्नुहुन्छ एवं चयन गर्नुहुन्छ?

Question

Accepted Answer

Go ले दुई प्रकारको समवर्तिता सुरक्षा अफर गर्दछ: **channels** ("मेमोरी साझा गरेर संचार गर्नुहोस्") र **`sync` प्याकेज** (mutexes/locks साझा मेमोरी सीधै सुरक्षित गर्न)। Go को channel-first दर्शनको बाबजुद, sync primitives अक्सर साझा अवस्था सुरक्षित गर्नको लागि सरल, अधिक प्रभावी विकल्प हो।

## sync.Mutex — साझा अवस्था लक संग सुरक्षित गर्नुहोस्

```go
type Counter struct {
    mu    sync.Mutex
    count int
}

func (c *Counter) Increment() {
    c.mu.Lock()           // acquire the lock — only one goroutine at a time past here
    defer c.mu.Unlock()    // release on return (defer ensures it always happens)
    c.count++              // safe — protected critical section
}
```

`Mutex` ले निश्चित गर्दछ कि केवल एक goroutine एकै पल सुरक्षित डेटा अ्याक्सेस गर्दछ, डेटा रेस रोक्दै। `Lock()`/`defer Unlock()` प्याटर्न idiomatic छ।

## sync.RWMutex — धेरै पाठक वा एक लेखक

```go
type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}
func (c *Cache) Get(key string) string {
    c.mu.RLock()           // READ lock — multiple readers allowed concurrently
    defer c.mu.RUnlock()
    return c.data[key]
}
func (c *Cache) Set(key, value string) {
    c.mu.Lock()            // WRITE lock — exclusive
    defer c.mu.Unlock()
    c.data[key] = value
}
```

`RWMutex` ले समवर्तिता पठन अनुमति दिन्छ तर एक्सक्लुसिभ लेखन — क्यास जस्ता पठन-भारी डेटाको लागि आदर्श।

## अन्य sync primitives

```go
sync.WaitGroup           // wait for a group of goroutines to finish (Add/Done/Wait)
sync.Once                // run something EXACTLY once (lazy init, singletons)
  var once sync.Once
  once.Do(initialize)    // initialize runs only on the first call, ever
sync.Map                 // a concurrent map (specialized cases)
atomic.AddInt64(&n, 1)   // lock-free atomic operations for simple counters
```

## sync बनाम channels कहिले प्रयोग गर्नुहोस्

```text
Use sync (Mutex/RWMutex/atomic) when:
  ✓ Protecting simple shared STATE (a counter, a cache, a map)
  ✓ The logic is "guard this data" — locking is simpler and faster than channels here
  ✓ Read-heavy data (RWMutex), one-time init (Once), simple counters (atomic)

Use channels when:
  ✓ COMMUNICATING/passing data between goroutines, signaling, coordinating
  ✓ Pipelines, worker distribution, ownership transfer
```

व्यावहारिक नियम: **"मेमोरी साझा गरेर संचार नगर्नुहोस्" एक दिशानिर्देश हो, हठधर्मिता होइन।** साधारणतया साझा अवस्था सुरक्षित गर्नको लागि, एक mutex channels मा तर्क contort गर्दा स्पष्ट र अधिक कुशल छ।

## किन यो महत्त्वपूर्ण छ

`sync` प्याकेज एवं channels कहिले प्रयोग गर्नुहोस् भनी जान्नु Go समवर्तिता परिपक्कताको मुख्य संकेत हो।

Go ले channels प्रवर्धन गर्दछ ("मेमोरी साझा गरेर संचार गर्नुहोस्"), तर यु दिशानिर्देश हो — र एक सामान्य गल्ती साधारण **mutex** अधिक स्पष्ट र द्रुत हुन सक्ने ठाँउ channels बाध्य गर्नु हो।

`sync` प्याकेज **साझा अवस्था सुरक्षित गर्नको लागि** (काउन्टर, क्यास, म्यापस्) सही, idiomatic उपकरण हो: एक्सक्लुसिभ अ्याक्सेसको लागि mutexes, पठन-भारी डेटाको लागि `RWMutex`, goroutines प्रतीक्षा गर्नको लागि `WaitGroup`, एक पल को प्रारम्भीकरण को लागि `Once`, र विशेष सन्दर्भको लागि `atomic`/`sync.Map`।

चयनहरु *संचार र समन्वय* मा उत्कृष्ट हुन्छन् जबकि sync primitives *साझा मेमोरी सुरक्षित गर्न* उत्कृष्ट हुन्छन् भनी बुझ्ने — र hठधर्मीय रूपमा channels को प्रयोग गर्नुको सट्टा उपयुक्त उपकरण चयन गर्ने — सरल, अधिक कुशल, अधिक सही समवर्तिता कोड को नेतृत्व गर्दछ।

यु निर्णय ठीक वही हो जु अनुभवी Go विकासक र एक बारम्बार उन्नत अन्तर्वार्ता विषय छ।