Melaksanakan pengaturcaraan serentak dalam bahasa Go: menguasai prinsip asas konkurensi

Melaksanakan pengaturcaraan serentak dalam bahasa Go: Kuasai prinsip asas konkurensi

Dalam bidang komputer moden, multi-teras dan multi-threading merupakan salah satu topik paling hangat hari ini. Pengaturcaraan serentak telah menjadi bahagian yang sangat penting dalam industri pembangunan perisian hari ini. Bahasa Go, sebagai bahasa pengaturcaraan yang telah mendapat perhatian yang semakin meluas, mempunyai tahap ciri konkurensi yang tinggi dan boleh membantu pembangun dengan mudah melaksanakan pengaturcaraan serentak.

Dalam artikel ini, kami menumpukan pada pengaturcaraan serentak dalam bahasa Go dan meneroka cara menguasai prinsip asas pengaturcaraan serentak.

1. Goroutine

Bahasa Go mempunyai coroutine (goroutine) sebagai blok binaan konkurensi asas Ia adalah urutan ringan dan diuruskan oleh persekitaran masa jalan bahasa Go. Dengan sokongan goroutine, bahasa Go boleh dengan mudah melaksanakan pengaturcaraan serentak yang cekap.

Menggunakan goroutine adalah sangat mudah, cuma tambah kata kunci "go" sebelum fungsi:

go func() {
  // 这里是需要异步执行的任务
}()

Anda juga boleh menggunakan fungsi yang mengandungi parameter untuk memulakan:

func work(done chan bool) {
  // 这里是异步任务，执行完成后通过done channel写入数据
  done<- true
}

done := make(chan bool)
go work(done)
<-done

2. Saluran

Saluran ialah satu lagi blok binaan serentak dalam bahasa Go Ia ialah kaedah penghantaran dan penyegerakan antara gorouti yang berbeza. Melalui Saluran, goroutine yang berbeza boleh menyampaikan data dengan selamat tanpa perlu risau tentang keadaan perlumbaan dan isu threading lain.

Bahasa Go menyediakan tiga saluran:

• Hanya menerima tetapi tidak menghantar (saluran <- T)
• Hanya menghantar tetapi tidak menerima (saluran lT -> )
• Komunikasi dua hala (saluran T)

Menggunakan saluran adalah sangat mudah, hanya gunakan fungsi buat untuk mencipta saluran:

ch := make(chan int)

Hantar data:

ch <- 1

Terima data:

v := <-ch

3. Mutex

Apabila berbilang goroutine mengakses sumber dikongsi pada masa yang sama, keadaan perlumbaan dan kebuntuan terdedah berlaku. Untuk menyelesaikan masalah ini, bahasa Go menyediakan jenis Mutex, yang boleh mengunci dan membuka kunci sumber yang dikongsi untuk memastikan bahawa hanya satu goroutine boleh mengakses sumber pada masa yang sama.

Menggunakan Mutex adalah sangat mudah, cuma tambah operasi kunci dan buka kunci sebelum dan selepas kod mengakses sumber yang dikongsi:

var mu sync.Mutex

mu.Lock()
// 这里是对共享资源的访问代码
mu.Unlock()

4. WaitGroup

dalam In pengaturcaraan serentak, kadangkala anda perlu menunggu semua gorout menyelesaikan tugas mereka sebelum melakukan operasi seterusnya. Pada masa ini, jenis WaitGroup boleh digunakan, yang boleh menunggu semua goroutine selesai sebelum melakukan operasi seterusnya.

Menggunakan WaitGroup adalah sangat mudah Anda hanya perlu menambah operasi Tambah sebelum memulakan goroutine, tambah operasi Selesai selepas tugasan goroutine selesai, dan kemudian gunakan operasi Tunggu dalam utas utama untuk menunggu sehingga. goroutine untuk dilengkapkan:

var wg sync.WaitGroup
for _, url := range urls {
  // 启动goroutine
  wg.Add(1)
  go func(url string) {
    http.Get(url)
    wg.Done() // 执行完毕
  }(url)
}
wg.Wait() // 等待所有goroutine完成

Ringkasan

Bahasa Go sememangnya dilengkapi dengan tahap keselarasan yang tinggi, menjadikannya bahasa pengaturcaraan yang sangat popular hari ini. Menguasai prinsip asas pengaturcaraan serentak dengan berkesan adalah kunci untuk mencapai program serentak yang cekap, stabil dan selamat. Dalam artikel ini, kami memperkenalkan blok binaan konkurensi utama dalam bahasa Go, termasuk Goroutine, Channel, Mutex dan WaitGroup. Dengan pemahaman yang mendalam tentang prinsip asas ini, ia boleh membantu pembangun melaksanakan pengaturcaraan serentak yang cekap dengan lebih mudah.

Atas ialah kandungan terperinci Melaksanakan pengaturcaraan serentak dalam bahasa Go: menguasai prinsip asas konkurensi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!