Golang melaksanakan pengaturcaraan serentak

Bahasa Go (golang) ialah bahasa pengaturcaraan serentak yang ringan, direka untuk memudahkan pembangun mengendalikan pengaturcaraan serentak. Golang menyediakan pelbagai ciri bahasa dan fungsi perpustakaan yang boleh melaksanakan tugas pengaturcaraan serentak tinggi dengan mudah. Artikel ini akan memperkenalkan kaedah dan teknik Golang untuk melaksanakan pengaturcaraan serentak.

1. Goroutine dan Saluran
Goroutines dan Saluran ialah dua konsep teras pengaturcaraan serentak di Golang. Goroutine ialah benang ringan di Golang Setiap fungsi di Golang boleh dijalankan sebagai Goroutine. Saluran ialah paip yang digunakan untuk komunikasi antara Goroutines, yang melaluinya data boleh dipindahkan antara berbilang Goroutines.

Contoh berikut menunjukkan cara melaksanakan program serentak mudah menggunakan Goroutines dan Saluran:

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started job", j)
        time.Sleep(time.Second)
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}

Dalam contoh di atas, fungsi pekerja berjalan sebagai goroutine, mengambil tugas daripada saluran paip kerja, Selepas pemprosesan, hasilnya dihantar ke saluran paip keputusan. Fungsi utama mencipta dua saluran paip, kerja dan hasil, menghantar tugasan ke saluran paip kerja, dan akhirnya menunggu semua keputusan dikeluarkan daripada saluran paip hasil.

2. WaitGroups
WaitGroups ialah satu lagi sumber utama dalam pustaka Golang Ia adalah satu mekanisme untuk menunggu kumpulan Goroutines menyelesaikan pelaksanaan. Apabila anda perlu menunggu sekumpulan Goroutine untuk menyelesaikan tugas tertentu, anda boleh menggunakan WaitGroup, yang menyediakan tiga kaedah: Tambah, Selesai dan Tunggu. Kaedah Tambah dalam kod menunjukkan bilangan Goroutine yang perlu menunggu, kaedah Selesai menunjukkan bahawa Goroutine tertentu telah menyelesaikan tugasan, dan kaedah Tunggu menyekat dan menunggu semua Goroutine menyelesaikan tugas.

Contoh berikut menunjukkan cara menggunakan WaitGroup untuk melaksanakan tugas serentak yang mudah:

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("Worker %d starting
", id)

    time.Sleep(time.Second)
    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()

    fmt.Println("All workers done")
}

Dalam contoh di atas, fungsi pekerja berjalan sebagai Goroutine, menunggu semua Goroutine selesai melalui WaitGroup. Dalam fungsi utama, buat WaitGroup dan gunakan kaedah Tambah untuk menyertai senarai menunggu kaedah The Done menunjukkan bahawa kaedah The Wait akan menyekat dan menunggu semua Goroutines menyelesaikan tugas.

3. Mutexes
Mutexes ialah satu lagi alat pengaturcaraan serentak yang sangat penting yang disediakan dalam pustaka Golang. Ia boleh memastikan keselamatan data apabila sumber dikongsi antara berbilang Goroutine. Ia boleh memastikan bahawa hanya satu Goroutine boleh mengakses sumber yang dikongsi pada masa yang sama dengan mengunci dan membuka kunci sumber.

Contoh berikut menunjukkan cara menggunakan Mutexes untuk melaksanakan tugas serentak:

package main

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

type SafeCounter struct {
    value int
    mutex sync.Mutex
}

func (c *SafeCounter) Increment() {
    c.mutex.Lock()

    c.value++
    fmt.Println(c.value)

    c.mutex.Unlock()
}

func main() {
    counter := SafeCounter{0, sync.Mutex{}}

    for i := 0; i < 10; i++ {
        go func() {
            for {
                counter.Increment()
                time.Sleep(time.Millisecond)
            }
        }()
    }
    time.Sleep(time.Second)
}

Dalam contoh di atas, jenis SafeCounter mengandungi nilai pembolehubah dan kunci mutex mutex. Kaedah Penambahan akan menambah 1 pada pembolehubah nilai Oleh kerana nilai ialah sumber yang dikongsi, mutex perlu dikunci dan dibuka kunci dalam kaedah untuk memastikan hanya satu Goroutine boleh mengakses pembolehubah nilai pada masa yang sama.

4. Atomic
Atomic ialah satu lagi alat pengaturcaraan serentak yang disediakan dalam pustaka Golang. Atomic menyediakan pelbagai operasi atom berdasarkan arahan CPU, seperti Tambah, Bandingkan-dan-tukar, Muatkan, Simpan dan kaedah lain.

Contoh berikut menunjukkan cara menggunakan Atomic untuk melaksanakan tugas serentak yang mudah:

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

func main() {
    var counter int32

    for i := 0; i < 10; i++ {
        go func() {
            for {
                atomic.AddInt32(&counter, 1)
                fmt.Println(atomic.LoadInt32(&counter))
                time.Sleep(time.Millisecond)
            }
        }()
    }
    time.Sleep(time.Second)
}

Dalam contoh di atas, pembilang dilaksanakan menggunakan kaedah AddInt32 dan LoadInt32 Atomic. Kaedah AddInt32 meningkatkan nilai kaunter, dan kaedah LoadInt32 memperoleh nilai semasa kaunter. Kerana operasi atom ini boleh memastikan keatoman operasi, ketepatan kenaikan kaunter boleh dijamin.

5. Pilih
Select ialah satu lagi alat pengaturcaraan serentak yang sangat penting di Golang Ia adalah mekanisme untuk menunggu mesej pada berbilang Saluran pada masa yang sama, yang boleh membantu pembangun mengendalikan tugas serentak yang kompleks. Dalam pernyataan Pilih, anda boleh mengisytiharkan berbilang Saluran, kemudian tunggu mana-mana Saluran untuk menghantar data, dan kemudian laksanakan logik yang sepadan.

Contoh berikut menunjukkan cara menggunakan pernyataan Pilih untuk melaksanakan tugas serentak yang mudah:

package main

import (
    "fmt"
    "time"
)

func main() {
    channel1 := make(chan string)
    channel2 := make(chan string)

    go func() {
        time.Sleep(time.Second)
        channel1 <- "Hello"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        channel2 <- "World"
    }()

    for i := 0; i < 2; i++ {
        select {
        case message1 := <-channel1:
            fmt.Println("Received message1", message1)
        case message2 := <-channel2:
            fmt.Println("Received message2", message2)
        }
    }
}

Dalam contoh di atas, dua Saluran diisytiharkan dalam fungsi utama: saluran1 dan saluran2. Gunakan dua Goroutine untuk menghantar mesej ke dua Saluran ini, kemudian gunakan Pilih dalam fungsi utama untuk menunggu penghantaran mesej, dan cetak maklumat yang sepadan mengikut situasi tertentu.

Kesimpulan
Golang menyediakan banyak alatan dan perpustakaan pengaturcaraan serentak yang berkuasa, termasuk Goroutines, Channels, WaitGroups, Mutexes, Atomic and Select, dsb. Alat ini memudahkan untuk melaksanakan tugas pengaturcaraan serentak yang cekap. Apabila menulis program serentak, anda perlu memberi perhatian untuk memastikan keselamatan dan ketepatan data untuk mengelakkan masalah seperti kebuntuan dan keadaan perlumbaan.

Atas ialah kandungan terperinci Golang melaksanakan pengaturcaraan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!