Farih.co.id
Home Programming Pengantar Konkurensi di Go

Pengantar Konkurensi di Go

go lang 2

Concurrency adalah aspek penting dari pengembangan perangkat lunak modern karena memungkinkan program menangani banyak tugas secara bersamaan secara efisien. Anda dapat menulis program yang menjalankan berbagai operasi yang menghasilkan peningkatan kinerja, daya tanggap, dan penggunaan sumber daya.


Concurrency adalah salah satu fitur yang bertanggung jawab atas adopsi cepat Go. Dukungan bawaan Go untuk pemrograman bersamaan dianggap mudah sambil membantu menghindari jebakan umum seperti kondisi balapan dan kebuntuan.


Konkurensi di Go

Go memberikan dukungan kuat untuk konkurensi melalui berbagai mekanisme, semuanya tersedia di pustaka standar dan rantai alatnya. Program Go mencapai konkurensi melalui goroutine dan saluran.

Goroutine ringan, menjalankan fungsi secara independen yang berjalan bersamaan dengan goroutine lain dalam ruang alamat yang sama. Goroutine memungkinkan banyak tugas untuk maju secara bersamaan tanpa manajemen utas eksplisit. Goroutine lebih ringan daripada thread sistem operasi dan Go dapat menjalankan ribuan atau bahkan jutaan goroutine secara bersamaan secara efisien.

Saluran adalah mekanisme komunikasi untuk koordinasi dan berbagi data antar goroutine. Saluran adalah saluran yang diketik yang memungkinkan goroutine mengirim dan menerima nilai. Saluran menyediakan sinkronisasi untuk memastikan berbagi data yang aman di antara goroutine sekaligus mencegah kondisi balapan dan masalah konkurensi umum lainnya.

Dengan menggabungkan goroutine dan saluran, Go menyediakan model konkurensi yang andal dan mudah yang menyederhanakan pengembangan program konkuren dengan tetap menjaga keamanan dan efisiensi. Mekanisme ini memungkinkan Anda untuk dengan mudah menggunakan prosesor multicore dan membangun aplikasi yang sangat skalabel dan responsif.

Cara Menggunakan Goroutine untuk Eksekusi Kode Bersamaan

Runtime Go mengelola goroutine. Goroutine memiliki tumpukannya sendiri, memungkinkan mereka memiliki tapak yang ringan dengan ukuran tumpukan awal beberapa kilobyte.

Goroutine dimultipleks ke beberapa utas OS oleh runtime Go. Penjadwal runtime Go menjadwalkannya ke thread yang tersedia dengan mendistribusikan beban kerja secara efisien, memungkinkan eksekusi bersamaan beberapa goroutine pada thread OS yang lebih sedikit.

Membuat goroutine sangatlah mudah. Anda akan menggunakan pergi keyword diikuti dengan pemanggilan fungsi untuk mendeklarasikan goroutine.

 func main() {
    go function1()
    go function2()

    
}

func function1() {
    
}

func function2() {
    
}

Saat program memanggil fungsi1() Dan fungsi2() dengan pergi kata kunci, runtime Go mengeksekusi fungsi secara bersamaan sebagai goroutine.

Berikut adalah contoh penggunaan goroutine yang mencetak teks ke konsol:

 package main

import (
    "fmt"
    "time"
)

func printText() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Printing text", i)
        time.Sleep(1 * time.Second)
    }
}

func main() {
    go printText()

    
    for i := 1; i <= 5; i++ {
        fmt.Println("Performing other tasks", i)
        time.Sleep(500 * time.Millisecond)
    }

    
    time.Sleep(6 * time.Second)
}

Itu printText fungsi berulang kali mencetak beberapa teks ke konsol dengan a untuk loop yang berjalan lima kali mengikuti penundaan satu detik antara setiap pernyataan dengan paket waktu.

Itu utama fungsi memulai goroutine dengan memanggil pergi printTextyang meluncurkan printText berfungsi sebagai goroutine bersamaan terpisah yang memungkinkan fungsi untuk mengeksekusi secara bersamaan dengan sisa kode di utama fungsi.

Terakhir, untuk memastikan bahwa program tidak keluar sebelum printText goroutine selesai, the waktu tidur fungsi menjeda goroutine utama selama enam detik. Dalam skenario dunia nyata, Anda akan menggunakan mekanisme sinkronisasi seperti saluran atau grup tunggu untuk mengoordinasikan eksekusi goroutine.

hasil dari mencetak teks dengan Goroutine

Menggunakan Saluran untuk Komunikasi dan Sinkronisasi

Goroutine memiliki dukungan bawaan untuk komunikasi dan sinkronisasi melalui saluran, membuat penulisan kode bersamaan lebih mudah daripada utas tradisional, yang seringkali memerlukan mekanisme sinkronisasi manual seperti kunci dan semaphore.

Anda dapat menganggap saluran sebagai saluran untuk aliran data antar goroutine. Satu goroutine dapat mengirim nilai ke saluran, dan goroutine lain dapat menerima nilai itu dari saluran. Mekanisme ini memastikan bahwa pertukaran data aman dan tersinkronisasi.

Anda akan menggunakan <- operator untuk mengirim dan menerima data melalui saluran.

Berikut adalah contoh yang menunjukkan penggunaan dasar saluran untuk komunikasi antara dua goroutine:

 func main() {
    
    ch := make(chan string)

    
    go func() {
        ch <- "Hello, Channel!"
    }()

    
    msg := <-ch
    fmt.Println(msg)
}

Saluran di utama function adalah saluran tanpa buffer bernama ch dibuat dengan membuat() fungsi. Goroutine pertama mengirimkan pesan “Hello, Channel!” ke dalam saluran menggunakan <- operator, dan goroutine kedua menerima pesan dari saluran menggunakan operator yang sama. Akhirnya, utama fungsi mencetak pesan yang diterima ke konsol.

hasil dari pencetakan pesan yang dikirimkan melalui saluran

Anda dapat menentukan saluran yang diketik. Anda akan menentukan jenis saluran pada pembuatan. Berikut adalah contoh yang menunjukkan penggunaan berbagai jenis saluran:

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

    
    ch2 := make(chan string, 3)

    
    ch1 <- 42
    value1 := <-ch1

    ch2 <- "Hello"
    value2 := <-ch2
}

Itu utama fungsi membuat dua saluran: bab 1 adalah saluran bilangan bulat tanpa buffer, sementara ch2 adalah saluran string buffer dengan kapasitas 3. Anda dapat mengirim dan menerima nilai ke dan dari saluran ini menggunakan <- operator (nilai harus dari tipe yang ditentukan).

Anda dapat menggunakan saluran sebagai mekanisme sinkronisasi untuk mengoordinasikan eksekusi goroutine dengan memanfaatkan sifat pemblokiran operasi saluran.

 func main() {
    ch := make(chan bool)

    go func() {
        fmt.Println("Goroutine 1")
        ch <- true
    }()

    go func() {
        <-ch
        fmt.Println("Goroutine 2")
    }()

    <-ch
    fmt.Println("Main goroutine")
}

Itu ch saluran adalah boolean. Dua goroutine berjalan bersamaan di utama fungsi. Goroutine 1 menandai penyelesaiannya dengan mengirimkan a BENAR nilai ke saluran ch. Goroutine 2 menunggu sinyal penyelesaian dengan menerima nilai dari saluran. Terakhir, goroutine utama menunggu sinyal penyelesaian dari goroutine dua.

Anda Dapat Membuat Aplikasi Web di Go With Gin

Anda dapat membuat aplikasi web berperforma tinggi di Go dengan Gin sambil memanfaatkan fitur konkurensi Go.

Anda dapat menggunakan Gin untuk menangani perutean HTTP dan middleware secara efisien. Manfaatkan dukungan konkurensi bawaan Go dengan menggunakan goroutine dan saluran untuk tugas seperti kueri basis data, panggilan API, atau operasi pemblokiran lainnya.

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

beli jitu https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad

BIJI18 BIJI18 https://goremekoop.com/ AGEN77 3DBET OBOR138 GACOR168JP YING77 RUMAH258 POHONHOKI99 ASALBET88 PARIS128 66KBET LONG111 DESA333 DEWAGACOR89 YING77
https://146.190.200.68/ https://188.166.204.36/