Home-theater-designers
Concurrency ialah aspek penting dalam pembangunan perisian moden kerana ia membolehkan program mengendalikan pelbagai tugas secara serentak dengan cekap. Anda boleh menulis program yang melaksanakan pelbagai operasi yang membawa kepada prestasi yang lebih baik, responsif dan penggunaan sumber.
Video MUO pada hari itu SCROLL UNTUK MENERUSKAN KANDUNGAN
Concurrency ialah salah satu ciri yang bertanggungjawab untuk penggunaan pantas Go. Sokongan terbina dalam Go untuk pengaturcaraan serentak dianggap mudah sambil membantu mengelakkan perangkap biasa seperti keadaan perlumbaan dan kebuntuan.
Concurrency dalam Go
Go menyediakan sokongan teguh untuk konkurensi melalui pelbagai mekanisme, semuanya tersedia dalam perpustakaan standard dan rantai alatnya. Pergi program mencapai keselarasan melalui goroutine dan saluran.
Goroutine adalah ringan, melaksanakan fungsi secara bebas yang berjalan serentak dengan goroutin lain dalam ruang alamat yang sama. Goroutines membenarkan berbilang tugasan berjalan serentak tanpa pengurusan benang yang jelas. Goroutines lebih ringan daripada rangkaian sistem pengendalian dan Go boleh menjalankan dengan cekap beribu-ribu malah berjuta-juta goroutine secara serentak.
cakera windows 10 pada 100%
Saluran ialah mekanisme komunikasi untuk penyelarasan dan perkongsian data antara goroutine. Saluran ialah saluran bertaip yang membolehkan goroutine menghantar dan menerima nilai. Saluran menyediakan penyegerakan untuk memastikan perkongsian data yang selamat antara goroutine sambil menghalang keadaan perlumbaan dan isu konkurensi biasa yang lain.
Dengan menggabungkan goroutin dan saluran, Go menyediakan model konkurensi yang berkuasa dan mudah yang memudahkan pembangunan program serentak sambil mengekalkan keselamatan dan kecekapan. Mekanisme ini membolehkan anda menggunakannya dengan mudah pemproses berbilang teras dan membina aplikasi yang sangat berskala dan responsif.
Cara Menggunakan Goroutines untuk Pelaksanaan Kod Serentak
Masa jalanan Go mengurus goroutine. Goroutine mempunyai timbunan mereka, membolehkan mereka mempunyai jejak yang ringan dengan saiz tindanan awal beberapa kilobait.
Goroutines dimultiplekskan ke beberapa urutan OS mengikut masa jalan Go. Penjadual masa jalan Go menjadualkannya ke urutan yang tersedia dengan mengagihkan beban kerja dengan cekap, membenarkan pelaksanaan serentak berbilang goroutin pada lebih sedikit urutan OS.
Mencipta goroutine adalah mudah. Anda akan menggunakan pergi kata kunci diikuti dengan panggilan fungsi untuk mengisytiharkan goroutine.
func main() {
go function1() // Create and execute goroutine for function1
go function2() // Create and execute goroutine for function2
// ...
}
func function1() {
// Code for function1
}
func function2() {
// Code for function2
}
Apabila program memanggil fungsi1() dan fungsi2() dengan pergi kata kunci, masa jalan Go melaksanakan fungsi secara serentak sebagai goroutine.
Berikut ialah 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() // Start a goroutine to execute the printText function concurrently
// Perform other tasks in the main goroutine
for i := 1; i <= 5; i++ {
fmt.Println("Performing other tasks", i)
time.Sleep(500 * time.Millisecond)
}
// Wait for the goroutine to finish
time.Sleep(6 * time.Second)
}
The printTeks fungsi berulang kali mencetak beberapa teks ke konsol dengan a untuk gelung yang berjalan lima kali berikutan kelewatan satu saat antara setiap pernyataan dengan pakej masa .
The utama fungsi memulakan goroutine dengan memanggil pergi printText , yang melancarkan printTeks berfungsi sebagai goroutine serentak yang berasingan yang membolehkan fungsi itu dilaksanakan serentak dengan kod yang lain dalam utama fungsi.
Akhir sekali, untuk memastikan bahawa program tidak keluar sebelum printTeks kemasan goroutine, yang masa.Tidur fungsi menjeda goroutine utama selama enam saat. Dalam senario dunia sebenar, anda akan menggunakan mekanisme penyegerakan seperti saluran atau kumpulan tunggu untuk menyelaraskan pelaksanaan goroutin.
Menggunakan Saluran untuk Komunikasi dan Penyegerakan
Goroutine mempunyai sokongan terbina dalam untuk komunikasi dan penyegerakan melalui saluran, menjadikan penulisan kod serentak lebih mudah daripada benang tradisional, yang selalunya memerlukan mekanisme penyegerakan manual seperti kunci dan semafor.
Anda boleh menganggap saluran sebagai saluran paip untuk aliran data antara gorouti. Satu goroutine boleh menghantar nilai ke saluran, dan satu lagi goroutine boleh menerima nilai itu daripada saluran. Mekanisme ini memastikan pertukaran data adalah selamat dan disegerakkan.
Anda akan menggunakan <- operator untuk menghantar dan menerima data melalui saluran.
Berikut ialah contoh yang menunjukkan penggunaan asas saluran untuk komunikasi antara dua goroutine:
func main() {
// Create an unbuffered channel of type string
ch := make(chan string)
// Goroutine 1: Sends a message into the channel
go func() {
ch <- "Hello, Channel!"
}()
// Goroutine 2: Receives the message from the channel
msg := <-ch
fmt.Println(msg) // Output: Hello, Channel!
}
Saluran dalam utama fungsi ialah saluran tidak buffer bernama ch dicipta dengan buat() fungsi. Goroutine pertama menghantar mesej 'Hello, Channel!' ke dalam saluran menggunakan <- operator, dan goroutine kedua menerima mesej daripada saluran menggunakan operator yang sama. Akhirnya, yang utama fungsi mencetak mesej yang diterima ke konsol.
Anda boleh menentukan saluran yang ditaip. Anda akan menentukan jenis saluran pada penciptaan. Berikut ialah contoh yang menunjukkan penggunaan jenis saluran yang berbeza:
func main() {
// Unbuffered channel
ch1 := make(chan int)
// Buffered channel with a capacity of 3
ch2 := make(chan string, 3)
// Sending and receiving values from channels
ch1 <- 42 // Send a value into ch1
value1 := <-ch1 // Receive a value from ch1
ch2 <- "Hello" // Send a value into ch2
value2 := <-ch2 // Receive a value from ch2
}
The utama fungsi mencipta dua saluran: ch1 ialah saluran integer tanpa buffer, manakala ch2 ialah saluran rentetan penimbal dengan kapasiti 3. Anda boleh menghantar dan menerima nilai ke dan dari saluran ini menggunakan <- operator (nilai mestilah daripada jenis yang ditentukan).
Anda boleh menggunakan saluran sebagai mekanisme penyegerakan untuk menyelaraskan pelaksanaan goroutine dengan memanfaatkan sifat penyekatan operasi saluran.
func main() {
ch := make(chan bool)
go func() {
fmt.Println("Goroutine 1")
ch <- true // Signal completion
}()
go func() {
<-ch // Wait for the completion signal from Goroutine 1
fmt.Println("Goroutine 2")
}()
<-ch // Wait for completion signal from Goroutine 2
fmt.Println("Main goroutine")
}
The ch saluran adalah boolean. Dua goroutine berjalan serentak dalam utama fungsi. Goroutine 1 menandakan siapnya dengan menghantar a benar nilai ke dalam saluran ch . Goroutine 2 menunggu isyarat siap dengan menerima nilai daripada saluran. Akhirnya, goroutine utama menunggu isyarat siap dari goroutine dua.
Anda Boleh Membina Apl Web dalam Go With Gin
Anda boleh membina apl web berprestasi tinggi dalam Go with Gin sambil memanfaatkan ciri serentak Go.
Anda boleh menggunakan Gin untuk mengendalikan penghalaan HTTP dan perisian tengah dengan cekap. Manfaatkan sokongan serentak terbina dalam Go dengan menggunakan gorout dan saluran untuk tugas seperti pertanyaan pangkalan data, panggilan API atau operasi penyekatan lain.