Bagaimana untuk menangani isu konkurensi dalam ujian fungsi Golang?

Dalam ujian fungsi Go, isu konkurensi boleh dikendalikan dengan teknik berikut: Gunakan sync.Mutex untuk menyegerakkan akses kepada sumber yang dikongsi. Gunakan sync.WaitGroup untuk menunggu goroutine keluar. Gunakan pakej atom untuk beroperasi pada pembolehubah kongsi serentak.

Panduan untuk menangani isu konkurensi dalam ujian fungsi Go

Konkurensi ialah konsep yang penting untuk pembangunan perisian moden, dan bahasa Go menyediakan cara sokongan yang kaya untuk mengendalikan senario serentak. Apabila menguji kod serentak, perhatian khusus diperlukan untuk memastikan bahawa ujian mencerminkan tingkah laku dunia sebenar dengan tepat.

Cause

Ujian fungsi Go dilaksanakan secara selari secara lalai, yang bermaksud berbilang ujian boleh dijalankan pada masa yang sama. Ini bagus untuk meningkatkan kecekapan ujian, tetapi boleh menyebabkan cabaran apabila menguji fungsi dengan serentak.

Penyelesaian

Beberapa teknik tersedia dalam Pergi untuk menangani isu dalam ujian serentak.

1. Gunakan sync.Mutex untuk mengakses sumber secara serentak

*Apabila berbilang goroutine perlu mengakses sumber yang dikongsi pada masa yang sama, sync.Mutex boleh memastikan bahawa hanya satu goroutine boleh mengakses sumber tersebut.
*Anda boleh menggunakan kaedah Mutex.Lock() dan Mutex.Unlock() untuk mengunci dan membuka kunci sumber kongsi masing-masing.
*Kes praktikal:

import (
    "sync"
    "testing"
)

func TestConcurrentMap(t *testing.T) {
    var mu sync.Mutex
    m := make(map[int]int)
    for i := 0; i < 10; i++ {
        go func(i int) {
            mu.Lock()
            m[i] = i
            mu.Unlock()
        }(i)
    }
    for i := 0; i < 10; i++ {
        want := i
        if got := m[i]; got != want {
            t.Errorf("unexpected value for key %d: got %d, want %d", i, got, want)
        }
    }
}

2. Gunakan sync.WaitGroup untuk menunggu goroutine keluar

*Apabila anda perlu memastikan semua goroutine telah menyelesaikan tugasnya sebelum ujian, sync.WaitGroup boleh digunakan untuk mengawal nombor goroutine menunggu.
*Anda boleh menggunakan kaedah WaitGroup.Add() dan WaitGroup.Wait() untuk meningkatkan dan menunggu bilangan goroutine masing-masing.
*Kes praktikal:

import (
    "sync"
    "testing"
)

func TestConcurrentRoutine(t *testing.T) {
    var wg sync.WaitGroup
    wg.Add(10)
    for i := 0; i < 10; i++ {
        go func(i int) {
            defer wg.Done()
            // wykonaj zadanie...
        }(i)
    }
    wg.Wait()
    // wszystkie rutyny zakończyły się...
}

3. Gunakan pakej atom untuk mengendalikan pembolehubah bersama serentak

*Apabila operasi atom (seperti peningkatan, penurunan) diperlukan pada pembolehubah bersama serentak, pakej atom menyediakan sokongan untuk operasi atom.
*Gunakan operasi atom seperti Load(), Store(), Add(), dsb. untuk memastikan operasi serentak adalah atom.
* Kes praktikal:

import (
    "sync/atomic"
    "testing"
)

func TestAtomicIncrement(t *testing.T) {
    var count uint64
    for i := 0; i < 10; i++ {
        go func() {
            for j := 0; j < 10; j++ {
                atomic.AddUint64(&count, 1)
            }
        }()
    }
    // 等待所有 goroutine 完成
    for i := 0; i < 10; i++ {
        time.Sleep(time.Millisecond * 100)
    }
    if value := atomic.LoadUint64(&count); value != 100 {
        t.Errorf("unexpected value for count: got %d, want 100", value)
    }
}

Kesimpulan

Dengan menggunakan teknik yang sesuai, isu konkurensi boleh dikendalikan dengan berkesan dalam ujian fungsi Go. Ini membantu memastikan ketepatan dan kebolehpercayaan keputusan ujian, menghasilkan kod yang lebih mantap dan boleh dipercayai.

Atas ialah kandungan terperinci Bagaimana untuk menangani isu konkurensi dalam ujian fungsi Golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!