Ulanish ro'yxatining elementlarini sinxronlashtirishni qanday amalga oshirish mumkin va bu qanday qilib ip xavfsizligini ta'minlaydi?

Go'da bog'langan ro'yxat bilan ishlashda oqim xavfsizligini ta'minlash uchun uning elementlariga kirishni sinxronlashtirish kerak, shunda raqobat sharoitlari oldini olinadi.

Asosiy yondashuvlar:

• O'qish va yozish operatsiyalarini bloklash uchun mutex (sync.Mutex yoki sync.RWMutex) dan foydalanish.
• Yuqori unumdorlik uchun, lock-free algoritmlar kabi murakkabroq tuzilmalar ishlatilishi mumkin, ammo bu qiyinroq.

sync.Mutex bilan misol:

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
}

Shu tarzda, ro'yxatni o'zgartiradigan yoki o'qiydigan barcha operatsiyalar mutex bilan himoyalangan, bu esa bir vaqtning o'zida kirishni oldini oladi.