Bagaimana untuk melaksanakan konkurensi dalam golang

Dengan perkembangan pesat pengkomputeran awan dan sains data, kami berhadapan dengan peningkatan keperluan untuk menyepadukan dan menganalisis set data yang besar. Dalam konteks ini, bahasa Go (pendek kata golang) semakin popular, terutamanya dalam pengaturcaraan serentak. Keupayaan konkurensi tinggi Golang dan model benang ringan (goroutine) menjadikannya pilihan ideal untuk mengendalikan tugas serentak. Dalam artikel ini, kita akan meneroka cara golang melaksanakan konkurensi.

Apa itu golang?

Bahasa Go ialah bahasa pengaturcaraan sumber terbuka yang direka oleh Google dan dikeluarkan pada tahun 2009. Ia direka bentuk untuk menjadi bahasa yang pantas, cekap dan selamat yang boleh mengatasi senario seperti aplikasi rangkaian dan sistem teragih yang memerlukan pemprosesan serentak yang tinggi. Ciri yang paling ketara bagi bahasa Go ialah model konkurensi "coroutine" yang ringan, yang boleh mencipta ratusan atau beribu-ribu tugas serentak tanpa perlu risau tentang masalah tindanan dan ingatan. Bahasa Go juga mempunyai kelebihan menaip yang kuat, pengumpulan sampah automatik dan ciri berorientasikan objek.

Cara Golang melaksanakan konkurensi

Model konkurensi Golang adalah berdasarkan konsep "coroutine", iaitu benang ringan (goroutine). Goroutine dalam golang adalah berbeza daripada benang sistem pengendalian (benang OS) dan boleh berjalan pada benang sistem pengendalian (model benang M:N). Kerana penciptaan dan pemusnahan goroutine adalah sangat ringan, golang boleh mencipta dan menguruskan sejumlah besar tugas dengan sangat cekap. Dalam golang, gunakan kata kunci "go" untuk memulakan goroutine:

func main() {
  go runTask()
}

func runTask() {
  //do something
}

Dalam contoh di atas, kami menggunakan kata kunci "go" untuk memulakan goroutine bernama "runTask". Apabila kita memanggil fungsi "runTask", ia akan berjalan dalam goroutine baharu dan dilaksanakan serentak dengan goroutine utama.

Selain itu, golang menggunakan "saluran" (saluran paip) untuk mencapai kawalan konkurensi dan penyegerakan data. Dalam golang, kita boleh menggunakan saluran dalam gorouti yang berbeza untuk berkomunikasi antara satu sama lain untuk mengawal akses serentak dan memastikan penyegerakan data.

func main() {
  ch := make(chan int)
  go addNums(ch)
  result := <- ch
  fmt.Println("The result is:", result)
}

func addNums(ch chan int) {
  sum := 0
  for i:=1; i<=10; i++ {
    sum += i
  }
  ch <- sum
}

Dalam contoh di atas, kami mencipta saluran integer dan memulakannya menggunakan fungsi "buat". Dalam fungsi "addNums", kami mengira jumlah nombor 1 hingga 10 dan menghantar hasilnya ke saluran. Dalam fungsi utama, kami menunggu keputusan dalam saluran dan mencetaknya.

Ringkasan

golang ialah bahasa yang sangat sesuai untuk pengaturcaraan serentak. Model konkurensi Golang adalah berdasarkan benang ringan (goroutine) dan saluran paip (saluran), jadi ia boleh mengendalikan tugas serentak dengan sangat cekap. Selain itu, golang juga menyediakan satu siri alatan dan perpustakaan standard untuk mengendalikan senario konkurensi, seperti pakej penyegerakan, pakej konteks, kumpulan tunggu, dsb. Sudah tentu, untuk menggunakan ciri konkurensi golang dengan betul, anda perlu memahami prinsip kerja dan amalan terbaiknya untuk mengelakkan akses serentak dan masalah penyegerakan data.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan konkurensi dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!