Artikel yang memperkenalkan kaedah penyegerakan di Golang

Golang ialah bahasa yang menyokong pengaturcaraan serentak, tetapi dalam pengaturcaraan serentak, ketidakkonsistenan data cenderung berlaku. Oleh itu, di Golang, kita perlu menggunakan kaedah penyegerakan untuk memastikan ketepatan dan kebolehpercayaan program. Artikel ini akan memperkenalkan kaedah penyegerakan di Golang.

1. Kunci Mutex

Kunci Mutex ialah salah satu mekanisme penyegerakan yang paling biasa digunakan Sumber yang dikongsi boleh dikunci melalui kunci mutex untuk memastikan hanya satu utas boleh mengakses sumber pada masa yang sama Perkongsian sumber mengelakkan berlakunya keadaan kaum. Di Golang, kunci mutex dilaksanakan melalui penyegerakan.Mutex dalam pustaka standard. Berikut ialah contoh kod untuk kunci mutex:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var lock sync.Mutex
    var wg sync.WaitGroup

    var count int

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            lock.Lock() // 加锁
            defer lock.Unlock() // 解锁

            count++
            time.Sleep(time.Second)
            fmt.Println(count)
            wg.Done()
        }()
    }

    wg.Wait()
}

2. Kunci baca-tulis

Kunci baca-tulis ialah kunci mutex khas yang membenarkan berbilang urutan mengakses data kongsi pada masa yang sama Sumber melakukan operasi baca, tetapi semasa operasi tulis, hanya satu utas boleh mengakses sumber yang dikongsi pada masa yang sama. Di Golang, kunci baca-tulis dilaksanakan melalui penyegerakan.RWMutex dalam pustaka standard. Berikut ialah contoh kod untuk kunci baca-tulis:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var lock sync.RWMutex
    var wg sync.WaitGroup

    var count int

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            // 多个线程读操作可以同时进行
            lock.RLock()
            fmt.Printf("读协程%d，count=%d\n", idx, count)
            lock.RUnlock()

            // 一个线程写操作时，其它线程无法读写
            lock.Lock()
            count++
            fmt.Printf("写协程%d，count=%d\n", idx, count)
            time.Sleep(time.Second)
            lock.Unlock()

            wg.Done()
        }(i)
    }

    wg.Wait()
}

3. Pembolehubah keadaan

Pembolehubah keadaan ialah mekanisme penyegerakan yang membenarkan benang disegerakkan berdasarkan keadaan tertentu. Di Golang, pembolehubah keadaan dilaksanakan melalui penyegerakan.Cond dalam perpustakaan standard. Berikut ialah contoh kod untuk pembolehubah keadaan:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var lock sync.Mutex
    var wg sync.WaitGroup
    var cond = sync.NewCond(&lock)

    done := false

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(idx int) {
            lock.Lock()
            for !done {
                cond.Wait() // 等待通知
            }
            fmt.Printf("协程%d收到通知\n", idx)
            lock.Unlock()

            wg.Done()
        }(i)
    }

    time.Sleep(time.Second)

    lock.Lock()
    done = true // 向所有协程发送通知
    cond.Broadcast()
    lock.Unlock()

    wg.Wait()
}

4. Operasi atom

Operasi atom ialah operasi yang boleh membaca dan menulis data memori tanpa mengunci . Di Golang, operasi atom dilaksanakan melalui penyegerakan/atom dalam perpustakaan standard. Berikut ialah kod sampel untuk operasi atom:

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var value int32
    atomic.StoreInt32(&value, 10)
    fmt.Println(atomic.LoadInt32(&value))

    atomic.AddInt32(&value, 5)
    fmt.Println(atomic.LoadInt32(&value))

    atomic.CompareAndSwapInt32(&value, 15, 20) // 如果value等于15，则将其更新为20
    fmt.Println(atomic.LoadInt32(&value))
}

Melalui kaedah penyegerakan seperti kunci mutex, kunci baca-tulis, pembolehubah keadaan dan operasi atom, kami boleh memastikan ketepatan dan kebolehpercayaan program Golang dengan berkesan. .

Atas ialah kandungan terperinci Artikel yang memperkenalkan kaedah penyegerakan di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!