Hogyan valósítjuk meg a láncolt lista elemeinek szinkronizálását a szálbiztonság biztosítása érdekében?

A Go-ban lévő összekapcsolt lista szálbiztonságának biztosítása érdekében szinkronizálni kell a hozzáférést az elemeihez, hogy elkerüljük a versenyhelyzeteket.

Fő megközelítések:

• Mutex (sync.Mutex vagy sync.RWMutex) használata az olvasási és írási műveletek zárolására.
• Magas teljesítmény esetén összetettebb struktúrák, például lock-free algoritmusok alkalmazhatók, de ez bonyolultabb.

Példa sync.Mutex használatával:

import "sync"

type Node struct {
    value int
    next  *Node
}

type LinkedList struct {
    head *Node
    mu   sync.Mutex
}

func (l *LinkedList) Add(value int) {
    l.mu.Lock()
    defer l.mu.Unlock()
    newNode := &Node{value: value}
    if l.head == nil {
        l.head = newNode
        return
    }
    current := l.head
    for current.next != nil {
        current = current.next
    }
    current.next = newNode
}

func (l *LinkedList) GetAll() []int {
    l.mu.Lock()
    defer l.mu.Unlock()
    var values []int
    current := l.head
    for current != nil {
        values = append(values, current.value)
        current = current.next
    }
    return values
}

Így minden, a lista módosítását vagy olvasását végző művelet mutex védelem alatt áll, ami megakadályozza a párhuzamos hozzáférési konfliktusokat.