Kā īstenot saistītā saraksta elementu sinhronizāciju, lai nodrošinātu pavedienu drošību?

Lai nodrošinātu plūsmas drošību, strādājot ar saistītu sarakstu Go valodā, ir nepieciešams sinhronizēt piekļuvi tā elementiem, lai izvairītos no sacensību stāvokļiem.

Galvenie pieejas veidi:

• Izmantot mutexu (sync.Mutex vai sync.RWMutex), lai bloķētu lasīšanas un rakstīšanas operācijas.
• Augstas veiktspējas gadījumā var izmantot sarežģītākas struktūras, piemēram, lock-free algoritmus, taču tas ir sarežģītāk.

Piemērs ar sync.Mutex:

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
}

Tādējādi, visi darbi, kas maina vai lasa sarakstu, ir aizsargāti ar mutex, novēršot vienlaicīgas piekļuves konfliktus.