Cathain a úsáideann tú an pacáiste sync in ionad channelanna?

Question

Accepted Answer

Cuireann Go dhá dhreach ar an tslándáil comthreallacha ar fáil: **channelanna** ("cuimhne a roinnt trí dhul i dteagmháil") agus an **pacáiste `sync`** (mutexes/glasanna chun cuimhne roinnte a chosaint go díreach). In ainneoin fealsunas Go atá dírithe ar channelanna, is minic gur is rogha níos simplí agus níos éifeachtúla iad primitives sync chun staid roinnte a chosaint.

## sync.Mutex — staid roinnte a chosaint le glas

```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
}
```

Cinnteoidh `Mutex` nach bhféadfaidh ach goroutine amháin an sonraí cosanta a rochtain ag an am céanna, agus cosc á chur ar rásaí sonraí. Is gnách an patrún `Lock()`/`defer Unlock()`.

## sync.RWMutex — go leor léitheoirí NÓ scríbhneoir amháin

```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
}
```

Ligfidh `RWMutex` do léamha comthreallacha ach scríobh eachtrannach — is deas-oiriúnach do shonraí atá agus an-chuid léamha iontu, ar nós taisce.

## Primitives eile sync

```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
```

## Cathain a úsáideann tú sync i gcoinne channelanna

```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
```

An riail phraicticiúil: **Ní is "Ná cumarsáid trí chuimhne a roinnt" ach treoir, ní ordóg an dlí.** Chun staid roinnte a chosaint go simplí, is soiléire agus níos tapúla a bhíonn mutex ná an loighic a dhéanamh ina channelanna.

## Cén fáth a bhíonn sé tábhachtach

Is comhartha tábhachtach d'aibíochtaí comthreallacha Go a bhíonn ann go bhfuil fios agat cathain a úsáideann tú an pacáiste `sync` i gcoinne channelanna.

Cé go bhíonn Go ag soiléiriú channelanna ("cuimhne a roinnt trí dhul i dteagmháil"), is treoir atá ann — agus is botún coitianta a bhíonn ann channelanna a bhríomadh i láithreacha inar mbeadh **mutex** simplí níos soiléire agus níos tapa.

Is an uirlis cheart, idiomataice an pacáiste `sync` chun **staid roinnte a chosaint** (cunntairí, taisce, mapaí): mutexes do rochtain eachtrannach, `RWMutex` do shonraí agus go leor léamha iontu, `WaitGroup` chun fanacht ar ghouroutines, `Once` do thúsú uair amháin, agus `atomic`/`sync.Map` do chásanna speisialta.

Tuigint go bhfuil channelanna ina scéalta ar a bharr ar *cumarsáid agus comhordú* agus go bhíonn primitives sync ina scéalta ar a bharr ar *chuimhne roinnte a chosaint* — agus an uirlis bhreá a roghnú in ionad channelanna a úsáid go dogmataice — sin a fhágann gur simplí, níos éifeachtúla, agus níos ceart an cód comthreallacha.

Is é an bhreithniú seo a dhéanann idirdhealú idir forbróirí taithiúla Go agus is ábhar achomhairc ard-leibhéal thúsantóireachta é.