GO: Concurrency vs Parallelism For Dummies.

Selamat datang ke siaran ini dengan tajuk yang agak merendahkan.
Tetapi, dalam post kali ini saya ingin menerangkan kepada anda apakah 2 ciri pengaturcaraan ini dengan cara yang sangat mudah, kali ini menggunakan bahasa pengaturcaraan kegemaran saya GOLANG.

Mari bayangkan dapur:

Memasak hidangan: Ini mewakili tugas.
Seorang tukang masak: Dia seorang pemproses.
Kehadiran:

Beberapa tukang masak di dapur: Masing-masing menyediakan hidangan yang berbeza.
In Go: Setiap tukang masak akan menjadi goroutine. Walaupun dapur (pemproses) hanya mempunyai satu ketuhar, tukang masak boleh memasak hidangan mereka secara serentak, meluangkan masa untuk tugas lain sementara menunggu ketuhar tersedia.
Paralelisme:

Pelbagai ketuhar: Setiap tukang masak mempunyai ketuhar sendiri.
In Go: Jika kita mempunyai berbilang pemproses fizikal, setiap goroutine boleh dijalankan pada pemproses yang berbeza, memasak beberapa hidangan pada masa yang sama dengan cara yang sebenar.

Apa bezanya?

Konkurensi: Tugasan dilaksanakan secara saling berkait, memberikan ilusi selari, walaupun pada satu pemproses.
Keselarian: Tugasan dijalankan serentak pada berbilang pemproses, yang mempercepatkan proses dengan ketara.

Bagaimana untuk menggunakannya dalam Go?

Groutine: Mereka seperti benang yang ringan. Untuk mencipta goroutine, kami hanya menggunakan kata kunci go sebelum fungsi:

Mari kita lihat contoh bagaimana kita boleh menggunakan goroutin dalam golang:

go func() {
    // Código que se ejecutará en una goroutine
}()

Saluran: Ini adalah paip yang melaluinya goroutine boleh berkomunikasi dan menyegerak.
Bayangkan mereka adalah tabung untuk menghantar bahan antara tukang masak

ch := make(chan int)
go func() {
    ch <- 42 // Enviar un valor por el canal
}()
value := <-ch // Recibir un valor del canal

Contoh praktikal:

package main

import (
    "fmt"
    "time"
)

func worker(id int, c chan int) {
    for n := range c {
        fmt.Printf("Worker %d received %d\n", id, n)
        time.Sleep(time.Second)
    }
}

func main() {
    c := make(chan int)

    for i := 1; i <= 5; i++ {
        go worker(i, c)
    }

    for n := 1; n <= 10; n++ {
        c <- n
    }
    close(c)

    time.Sleep(time.Second)
}

Output kod ini ialah

Worker 1 received 1
Worker 2 received 2
Worker 3 received 3
Worker 4 received 4
Worker 5 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 4 received 9
Worker 5 received 10

walaupun kadangkala ia boleh kelihatan seperti ini

Worker 5 received 1
Worker 1 received 3
Worker 2 received 2
Worker 4 received 5
Worker 3 received 4
Worker 3 received 6
Worker 5 received 10
Worker 2 received 8
Worker 4 received 7
Worker 1 received 9

atau seperti ini

Worker 5 received 1
Worker 1 received 2
Worker 2 received 3
Worker 3 received 4
Worker 4 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 5 received 9
Worker 4 received 10

Mengapa output berubah setiap kali saya menjalankan program?

Sebab utama output program berubah setiap larian adalah disebabkan sifat keselarasan yang tidak menentukan.

Berikut ialah pecahan perkara yang berlaku:

Buat saluran: make(chan int) mencipta saluran integer. Saluran ini akan digunakan untuk komunikasi antara goroutine.

Mulakan goroutine: Gelung untuk i := 1; i Fungsi pekerja menerima ID dan saluran.

Hantar nilai ke saluran: Gelung untuk n := 1; n 1 kepada 10 ke saluran.

Tutup saluran: Panggilan tutup(c) menutup saluran, menunjukkan bahawa tiada lagi nilai akan dihantar.

Terima nilai daripada saluran: Setiap goroutine menerima nilai daripada saluran menggunakan gelung untuk n := julat c. Apabila nilai diterima, ia dicetak ke konsol.

Tunggu sehingga goroutine selesai: Panggilan masa.Sleep(time.Second) memastikan goroutine utama menunggu goroutine lain selesai sebelum keluar.

Setakat ini:

Kami mencipta 5 goroutine (tukang masak) yang menerima nombor melalui saluran.
Kami menghantar nombor ke saluran untuk diproses oleh tukang masak.
Tukang masak bekerja serentak, memproses nombor semasa mereka menerimanya.

Mengapa menggunakan concurrency dan paralelisme dalam Go?

Prestasi yang lebih baik: Terutamanya dalam tugas terikat I/O (seperti membaca fail atau membuat permintaan HTTP).
Meningkatkan responsif: Aplikasi boleh terus membalas permintaan lain semasa tugasan dikunci.
Lebih banyak seni bina berskala: Anda boleh mengagihkan kerja merentasi berbilang teras atau mesin.

Ingat!

Konkurensi dan selari ialah alat yang berkuasa, tetapi ia juga boleh menjadikan kod lebih kompleks untuk difahami dan nyahpepijat. Adalah penting untuk menggunakannya dengan berhati-hati dan memahami implikasinya.

Adakah anda ingin mendalami topik tertentu?

Kita boleh meneroka konsep seperti:

Penyegerakan: Mutex, kumpulan kerja, dsb.
Corak konkurensi: Pengeluar-pengguna, saluran paip, dsb.
Ujian Serentak: Cara Menguji Kod Serentak Dengan Berkesan.

Salam,
Lucatonny Raudales

X/Twitter
Github

Atas ialah kandungan terperinci GO: Concurrency vs Parallelism For Dummies.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!