Teknologian jakaminen

Go-korutiinien ja kanavien kattavat sovelluskysymykset

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Ymmärrä lyhyesti, mitä korutiinit ja kanavat ovat

Mikä on korutiini

Korutiini on käyttäjätason kevyt säie, jolla on itsenäinen pinotila ja joka jakaa ohjelman pinotilan.

Se on yhden säikeen algoritmien avulla toteutettu mikrosäie Monisäikeiseen ohjelmointiin verrattuna sillä on seuraavat edut:

  • Korutiinin kontekstin vaihtamisen päättää käyttäjä ilman järjestelmän ytimen kontekstin vaihtoa, mikä vähentää yleiskustannuksia.
  • Oletusarvoisesti korutiinit ovat täysin suojattuja keskeytyksiä estämiseksi.Ei vaadi atomikäyttölukkoa
  • Yksi säie voi myös saavuttaa korkean samanaikaisuuden, ja jopa yksiytiminen CPU voi tukea kymmeniä tuhansia korutiineja.

mikä on kanava

Kanava on tietorakenne, jota käytetään tiedonsiirtoon korutiinien välillä. Kuten jonossa, toinen pää on lähettäjä ja toinen pää on vastaanottaja. Kanavien avulla voidaan varmistaa tietojen synkronointi ja järjestys.

Kanavat on jaettu puskuroituihin ja puskuroimattomiin kanaviin, jotka ilmoitetaan seuraavasti:

  • Siellä on puskurikanava
intChan := make(chan int,<缓冲容量>)
  • puskuroimaton kanava
intChan := make(chan int)

Ero puskuroitujen ja puskuroimattomien kanavien välillä:

  • Esto: Puskuroimattoman kanavan lähettäjä estää, kunnes data on vastaanotettu, puskuroidun kanavan lähettäjä estää, kunnes puskuri on täynnä, ja vastaanottaja estää, kunnes puskuri ei ole tyhjä.
  • Tietojen synkronointi ja järjestys: Puskuroimattomat kanavat takaavat tietojen synkronoinnin ja puskuroidut putket eivät takaa tietojen synkronointia ja järjestystä.
  • Sovellusskenaariot: Puskuroimattomat kanavat vaativat tiukan synkronoinnin ja puskuroidut kanavat voivat kommunikoida asynkronisesti ja parantaa suorituskykyä.

Puskuroimattomien kanavien toteutuksessa on huomioitava, että kanavan molemmissa päissä on oltava lähettäjä ja vastaanottaja, muuten tapahtuu lukkiutuminen.

2. Korutiinikanavan samanaikainen ohjelmointitapaus

(1) Tulosta kirjaimia ja numeroita vuorotellen

Kysymyksen merkitys: Käytä corutine-channel tulostaaksesi vuorotellen numerot 1-10 ja kirjaimet AJ.

Koodi:

  1. package main
  2.  
  3. import (
  4. 	"fmt"
  5. 	"sync"
  6. )
  7.  
  8. /*
  9. 无缓冲chanel：需要在写入chanel的时候要保证有另外一个协程在读取chanel。否则会导致写端阻塞，发生死锁
  10. 解决办法：
  11. 避免死锁的发生：
  12. 当i循环到10时，printAlp协程已然结束，所以此时不必再写入alp通道
  13. */
  14.  
  15. func printNum(wg *sync.WaitGroup, numCh chan struct{}, alpCh chan struct{}) {
  16. 	defer wg.Done()
  17.  
  18. 	for i := 1; i <= 10; i++ {
  19. 		<-alpCh // 等待字母goroutine发信号
  20. 		fmt.Print(i, " ")
  21. 		//避免死锁发生
  22. 		if i < 10 {
  23. 			numCh <- struct{}{} // 发信号给字母goroutine
  24. 		}
  25. 		if i == 10 {
  26. 			close(numCh)
  27. 		}
  28. 	}
  29.  
  30. }
  31.  
  32. func printAlp(wg *sync.WaitGroup, numCh chan struct{}, alpCh chan struct{}) {
  33. 	defer wg.Done()
  34.  
  35. 	for i := 'A'; i <= 'J'; i++ {
  36. 		<-numCh // 等待数字goroutine发信号
  37. 		fmt.Printf("%c", i)
  38. 		alpCh <- struct{}{} // 发信号给数字goroutine
  39. 	}
  40. 	close(alpCh)
  41. }
  42.  
  43. func main() {
  44. 	numCh := make(chan struct{}) // 用于数字goroutine的信号通道
  45. 	alpCh := make(chan struct{}) // 用于字母goroutine的信号通道
  46. 	var wg sync.WaitGroup
  47.  
  48. 	wg.Add(2)
  49.  
  50. 	go printAlp(&wg, numCh, alpCh)
  51. 	go printNum(&wg, numCh, alpCh)
  52.  
  53. 	// 启动时先给数字goroutine发送一个信号
  54. 	numCh <- struct{}{}
  55.  
  56. 	wg.Wait()
  57.  
  58. }

Aiheanalyysi:

Kysymys edellyttää meidän tulostavan vuorotellen kirjaimia ja numeroita, joten meidän on varmistettava kahden korutiinin tiukka järjestys, mikä on yhdenmukainen puskuroimattomien kanavien sovellusskenaarion kanssa. Aseta kaksi kanavaa tallentaaksesi numerot ja kirjaimet. Kaksi riviä, jotka tulostavat numeroita ja kirjaimia, toimivat kummankin kanavan lähettäjänä ja vastaanottajana. Tulosta kerran silmukassa ja lähetä signaali kerran muistuttaaksesi toista korutiinia tulostamisesta.

On huomioitava, että kun viimeinen merkki '10' on tulostettu, kirjainten tulostus on päättynyt ja numCh-kanavalla ei ole vastaanotinta. Tällä hetkellä puskuroimattoman kanavan toteutusehdot eivät enää täyty Lähettäjä ja vastaanottaja Muutoin signaalin lähettäminen uudelleen aiheuttaa lukkiutumisen. Joten signaalia ei tarvitse lähettää uudelleen 10. kertaa.

(2) Suunnittele tehtävien ajoitus

Otsikko: Suunnittele tehtävien ajoitus, joka käyttää monikorutiini + kanavaohjelmointimallia toteuttamaan liiketoimintaskenaarioita useiden tehtävien samanaikaista käsittelyä varten, ja ajoitusjärjestyksen on oltava siinä järjestyksessä, jossa tehtävät lisätään.

Koodi:

  1. type scheduler struct {
  2. 	taskChan chan func()
  3. 	wt       sync.WaitGroup
  4. }
  5.  
  6. func (td *scheduler) AddTask(task func()) {
  7. 	td.taskChan <- task
  8. }
  9.  
  10. func (td *scheduler) Executer() {
  11. 	defer td.wt.Done()
  12. 	for {
  13. 		task, ok := <-td.taskChan
  14. 		task()
  15. 		if ok && len(td.taskChan) == 0 {
  16. 			break
  17. 		}
  18. 	}
  19. }
  20.  
  21. func (td *scheduler) Start() {
  22. 	td.wt.Add(4)
  23. 	//假设四个消费者
  24. 	for i := 0; i < 4; i++ {
  25. 		go td.Executer()
  26. 	}
  27.  
  28. 	td.wt.Wait()
  29. }
  30.  
  31. func main() {
  32. 	sd := scheduler{
  33. 		taskChan: make(chan func(), 5),
  34. 	}
  35.  
  36. 	go func() {
  37. 		sd.AddTask(func() {
  38. 			fmt.Println("任务1")
  39. 		})
  40. 		sd.AddTask(func() {
  41. 			fmt.Println("任务2")
  42. 		})
  43. 		sd.AddTask(func() {
  44. 			fmt.Println("任务3")
  45. 		})
  46. 		sd.AddTask(func() {
  47. 			fmt.Println("任务4")
  48. 		})
  49. 		sd.AddTask(func() {
  50. 			fmt.Println("任务5")
  51. 		})
  52. 		sd.AddTask(func() {
  53. 			fmt.Println("任务6")
  54. 		})
  55. 		close(sd.taskChan)
  56. 	}()
  57.  
  58. 	sd.Start()
  59.  
  60. }

ongelmaanalyysi:

Koska lisätyt tehtävät ovat useita tehtäviä, niitä on enemmän kuin yksi, ja näiden tehtävien suorittaminen edellyttää asynkronista käsittelyä. Puskuroitujen kanavien noudattaminen vaatii parempaa suorituskykyä ja asynkronista käsittelyä.

Sitten meidän on asetettava tehtävä kanavalle, ja useat vastaanottimet voivat ottaa tehtävät kanavalta järjestyksessä ja suorittaa ne.

Yksi huomioitava asia on, että jos lisättyjen tehtävien määrä on suurempi kuin kanavapuskuri, se aiheuttaa eston tehtäviä lisättäessä. Jotta se ei vaikuta kuluttajan normaaliin käynnistykseen, sen on avattava erillinen korutiini tehtävien lisäämistä varten.

Tällä tavalla, kun kuluttaja kuluttaa, estotuottaja herätetään jatkamaan tehtävien lisäämistä.

3. Yhteenveto

Korutiini + kanavaohjelmointimallin tutkittuamme, otsikossa mainitun lisäksi, kannattaa kiinnittää huomiota myös seuraaviin asioihin:

1. Miksi kanava pitäisi sulkea sen jälkeen, kun se on käytetty loppuun. Mitä riskejä sen sulkematta jättäminen aiheuttaa?

  • Välttääksesi umpikujan. Kanavan sulkeminen kertoo myös vastaanottajalle, että lähettäjältä ei ole enää lähetettävää dataa eikä dataa tarvitse odottaa. Vastaanotettuaan kanavan sulkemistiedot, vastaanotin lopettaa tietojen vastaanottamisen, jos kanavaa ei ole suljettu, vastaanotin pysyy lukittuna ja on olemassa lukkiutumisen vaara.
  • Vapauta resurssit ja vältä resurssivuodot. Kanavan sulkemisen jälkeen järjestelmä vapauttaa vastaavat resurssit. Kanavan sulkeminen ajoissa voi välttää resurssien tuhlauksen ja vuodon.

2. Kuinka sulkea kanava kauniisti?

Ensinnäkin kanavien sulkemisen perusperiaate on olla sulkematta suljettuja kanavia. Toiseksi Go-kanavien käytössä on toinen periaate:Älä sulje kanavaa datavastaanottimessa tai jos lähettäjiä on useita.toisin sanoen，Meidän tulisi antaa vain kanavan ainoan lähettäjän sulkea tämä kanava.

Epäkohtelias tapa on sulkea kanava poikkeuspalautuksen avulla, mutta tämä on ilmeisesti vastoin yllä olevia periaatteita ja voi aiheuttaa datakilpailun. Toinen tapa on sulkea kanava sync.Once- tai sync.Mutex-toiminnolla, jonka toteutumista ei taata operaatiot ja lähetystoiminnot kanavalla eivät luo datakilpailuja. Molemmilla tavoilla on tiettyjä ongelmia, joten en esittele niitä yksityiskohtaisesti. Tässä on menetelmä kanavan sulamiseen.

Skenaario 1: M vastaanottajaa ja yksi lähettäjä

Yksi helpoimmista tilanteista käsitellä. Kun lähettäjän on lopetettava lähetys, anna sen sulkea kanava. Näin on kahdessa yllä olevassa ohjelmointiesimerkissä.

Skenaario 2: Yksi vastaanottaja ja N lähettäjää

Go-kanavien perusperiaatteiden mukaan voimme sulkea kanavan vain kanavan ainoalta lähettäjältä. Joten tässä tapauksessa emme voi sulkea kanavaa suoraan jonnekin.Mutta voimme antaa vastaanottimen sulkea ylimääräisen signaalikanavan, jotta lähettäjä ei lähetä enempää dataa.。

  1. package main
  2.  
  3. import (
  4. 	"log"
  5. 	"sync"
  6. )
  7.  
  8. func main() {
  9.  
  10. 	cosnt N := 5
  11. 	cosnt Max := 60000
  12. 	count := 0
  13.  
  14. 	dataCh := make(chan int)
  15. 	stopCh := make(chan bool)
  16.  
  17. 	var wt sync.WaitGroup
  18. 	wt.Add(1)
  19.  
  20. 	//发送者
  21. 	for i := 0; i < N; i++ {
  22. 		go func() {
  23. 			for {
  24. 				select {
  25. 				case <-stopCh:
  26. 					return
  27. 				default:
  28. 					count += 1
  29. 					dataCh <- count
  30. 				}
  31. 			}
  32. 		}()
  33. 	}
  34.  
  35. 	//接收者
  36. 	go func() {
  37. 		defer wt.Done()
  38. 		for value := range dataCh {
  39. 			if value == Max {
  40. 				// 此唯一的接收者同时也是stopCh通道的
  41. 				// 唯一发送者。尽管它不能安全地关闭dataCh数
  42. 				// 据通道，但它可以安全地关闭stopCh通道。
  43. 				close(stopCh)
  44. 				return
  45. 			}
  46. 			log.Println(value)
  47. 		}
  48. 	}()
  49.  
  50. 	wt.Wait()
  51. }

Tässä menetelmässä lisäämme ylimääräisen signaalikanavan stopCh, jonka avulla vastaanotin ilmoittaa lähettäjälle, ettei sen tarvitse enää vastaanottaa dataa. Lisäksi tämä menetelmä ei sulje dataCh:tä, kun kanavaa ei enää käytä mikään korutiini, se kerätään vähitellen, riippumatta siitä, onko se suljettu.

Tämän menetelmän tyylikkyys on, että sulkemalla yhden kanavan lopetat toisen kanavan käytön ja suljet siten epäsuorasti toisen kanavan.

Skenaario 3: M vastaanotinta ja N lähettäjää

Emme voi saada joko vastaanottajaa tai lähettäjää sulkemaan datan lähettämiseen käytettyä kanavaa, emmekä voi saada yhtä useista vastaanottimista sulkemaan ylimääräistä signalointikanavaa. Molemmat käytännöt rikkovat kanavan sulkemisperiaatetta.

Voimme kuitenkin esitelläVälivälittäjärooli ja se sulkee lisäsignalointikanavia ilmoittaakseen kaikille vastaanottajille ja lähettäjille työn päättymisestä。

Esimerkki koodista:

  1. package main
  2.  
  3. import (
  4. 	"log"
  5. 	"math/rand"
  6. 	"strconv"
  7. 	"sync"
  8. )
  9.  
  10. func main() {
  11.  
  12. 	const Max = 100000
  13. 	const NumReceivers = 10
  14. 	const NumSenders = 1000
  15.  
  16. 	var wt sync.WaitGroup
  17. 	wt.Add(NumReceivers)
  18.  
  19. 	dataCh := make(chan int)
  20. 	stopCh := make(chan struct{})
  21. 	// stopCh是一个额外的信号通道。它的发送
  22. 	// 者为中间调解者。它的接收者为dataCh
  23. 	// 数据通道的所有的发送者和接收者。
  24. 	toStop := make(chan string, 1)
  25. 	// toStop是一个用来通知中间调解者让其
  26. 	// 关闭信号通道stopCh的第二个信号通道。
  27. 	// 此第二个信号通道的发送者为dataCh数据
  28. 	// 通道的所有的发送者和接收者，它的接收者
  29. 	// 为中间调解者。它必须为一个缓冲通道。
  30.  
  31. 	var stoppedBy string
  32.  
  33. 	// 中间调解者
  34. 	go func() {
  35. 		stoppedBy = <-toStop
  36. 		close(stopCh)
  37. 	}()
  38.  
  39. 	// 发送者
  40. 	for i := 0; i < NumSenders; i++ {
  41. 		go func(id string) {
  42. 			for {
  43. 				value := rand.Intn(Max)
  44. 				if value == 0 {
  45. 					// 为了防止阻塞，这里使用了一个尝试
  46. 					// 发送操作来向中间调解者发送信号。
  47. 					select {
  48. 					case toStop <- "发送者#" + id:
  49. 					default:
  50. 					}
  51. 					return
  52. 				}
  53.  
  54. 				select {
  55. 				case <-stopCh:
  56. 					return
  57. 				case dataCh <- value:
  58. 				}
  59. 			}
  60. 		}(strconv.Itoa(i))
  61. 	}
  62.  
  63. 	// 接收者
  64. 	for i := 0; i < NumReceivers; i++ {
  65. 		go func(id string) {
  66. 			defer wt.Done()
  67.  
  68. 			for {
  69. 				select {
  70. 				case <-stopCh:
  71. 					return
  72. 				case value := <-dataCh:
  73. 					if value == Max {
  74. 						// 为了防止阻塞，这里使用了一个尝试
  75. 						// 发送操作来向中间调解者发送信号。
  76. 						select {
  77. 						case toStop <- "接收者:" + id:
  78. 						default:
  79. 						}
  80. 						return
  81. 					}
  82.  
  83. 					log.Println(value)
  84. 				}
  85. 			}
  86. 		}(strconv.Itoa(i))
  87. 	}
  88.  
  89. 	wt.Wait()
  90. 	log.Println("被" + stoppedBy + "终止了")
  91.  
  92. }

Henkilökohtainen profiili

Hän on omistautunut teknologian tutkimukselle yli 30 vuoden ajan ja hallitsee useita kieliä, kuten java, linux, javascript, php, css jne. Hän on tehnyt paljon työtä avoimen lähdekoodin alalla Kehittäjän dokumentaatioasema jakaaksesi joitain teknologian kehityksen ongelmia tulevaa käyttöä varten

yhteystietoni

Mail