Technology sharing

Comprehensiva applicationis quaestiones de Coroutines et canales Ite

2024-07-12

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

1. Breviter intelligere quid coroutines et canales sunt

Quid est coroutine

Coroutinum est filum leve-gradu usoris quod spatium acervum sui iuris habet et spatium cumulum programmatis communicat.

Micro-fila per algorithms in ex uno sequela comparata est, cum multi-filam programmandi comparata, sequentia commoda habet:

  • Contextus permutatio coroutini ab utentis decernitur, sine necessitate contextus mutandi nuclei systematis, caput reducendi.
  • Defaltam, coroutines ne interruptiones plene muniantur.Nulla nuclei operatio cincinno requiratur
  • Unum linum etiam concursum altum consequi potest, et etiam unum nucleum CPU decem milia coroutinum sustinere potest.

quid channel?

Channel data est structura ad communicationem inter coroutines adhibita. A queue similis, unus finis est mittenti et alter finis receptor. Usura canales efficere potest synchronisationem et ordinem notitiae.

Canales dividuntur in canales buffered et canales sineferos, qui hoc modo declarantur:

  • Est quiddam channel
intChan := make(chan int,<缓冲容量>)
  • unuffered channel
intChan := make(chan int)

Discrimen inter canales buffered et canales non effertos;

  • Clausus: Missor alvei soluti obstruet donec notitia recipiatur; Mittens canalem buffered obstruet usque dum quiddam plenum est, et acceptor obstruet donec quiddam vacuum non sit.
  • Data synchronisation and sequence: canales non buffered synchronisation and sequence data spondent;
  • Applicationes missiones: canales sine offensis strictam synchronizationem et seriem requirunt;

Quod notandum est in exsequendis canalibus intemperatis est mittente et receptore ad utrumque alveum esse oportere, alioquin morticinum erit.

2. Coroutine-alveum concurrentem programmandi causa

(I) Print litterae et numeri alternatim

Quaeritur significatio: Utere canali coroutino ad imprimendos numeros alternatim 1-10 et litteras AJ.

Codicis:

  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. }

Analysis topic:

Interrogatio nos postulat ut epistolas et numeros alternatim imprimant, ut necesse sit ut ordo districtus duorum coroutinorum, qui applicatione canalium non effusorum missione congruat. Duos canales constitue ut numeros et litteras respective condant. Imprime semel in ansa et signum mittat semel ut alium coroutinum imprimat admoneat.

Animadvertendum est, cum ultima characteris "10" impressus est, coroutinum litterarum imprimendi finivit, et numCh alveus non habet receptorem. Hoc tempore, condiciones exsecutionis canalis gratis non amplius convenerunt - oportet esse Mittens et Receptaculum. Alioquin mittens signum iterum claudendi causa deadlock. Itaque non est necesse ut signum iterum 10 tempore mittat.

(II) Designare negotium scheduler

Title: Designa munus scheduler quod utitur exemplo programmandi multi-coroutine + canalis ad negotium deducendi missiones concurrentis processus multi- munerum, et requirit schedulingum ordinem quo adduntur opera.

Codicis:

  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. }

quaestio analysis:

Cum multae functiones additae sint, plus quam unum est, et processus asynchronus ad haec munera exercenda requiritur. Obsequor canalibus buffered emendatis throughput et asynchronous processui requirit.

Tum opus in canalem imponere oportet, multique accipientes munus ab alveo accipere possunt ut ea exequantur et exsequantur.

Problema, quod attentione indiget, est quod, si numerus operum additorum maior est quam quiddam canalis, obturationem faciet cum muneribus additis. Ut normalem satus of perussi non afficit, coroutine separatum aperire debet opera addere.

Hoc modo, cum consumit edax, effectrix interclusio excitabitur ad operas addendo.

3. Libri

Postquam exemplar programmationis coroutine + canalis pervestigamus, praeter ea quae in titulo proxime nominata sunt, etiam ad quaestiones sequentes attendendum debemus:

1. Cur alveus claudendus est postquam consumitur?

  • Ad vitare deadlock. Canalem claudunt etiam receptatorem narrat nulla plus data esse ut mittat a mittente et non opus est ut notitias exspectando pergas. Recepta canalis claudendi informationes, receptaculum sistit notitia accepta; si canalis non clauditur, acceptor clausus remanebit et periculum deadlock est.
  • Dimitte opes et fuge resource pinum. Post canalem claudendum, systema debitas facultates solvet.

2. Quomodo canalem lepide claudere?

Ante omnia, principium principalissimum canalium claudendi non est claudere canales clausis. Secundo est aliud principium utendi canales Go;Noli claudere canalem in notitia accipientis vel cum plures sunt mittentes.in aliis verbis，Tantum canalem mittentem solum hunc canalem claudere debemus.

Via rudis est claudere canalem per receptam exceptionem, sed manifesto illa principia violat, et genus notitiarum causare potest; alius modus est sync. Mutex claudere canalem operationes et operationes in canalem mittere non faciunt data gentes. Utriusque modi problemata quaedam habent, ideo eas singillatim non introducebo. Hic modus est quomodo canalem lepide claudat.

Sem I: M receptores et mittentis

Una ex facillimis adiunctis euenit. Cum mittens necesse est ut mittendo perficiat, canalem mox claudat. Ita est in duobus programmatis exemplis.

Sem II: unus receptor et N mittentes

Secundum principia fundamentalia Canalium Go, solum possumus canalem claudere ad unicum mittente canalis. Ita, hoc casu, alveum alicubi directe claudere non possumus.Sed accipientem prope canalem additicium signum permittere possumus ut mittente non amplius notitias mitteret.。

  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. }

Hoc pacto addito canali stopCh signo addito, quo receptor utitur ad mittente indicandam notitias recipere non amplius oportere. Haec autem methodus dataCh non claudit. Cum canalis coroutine nulla amplius adhibetur, paulatim coeno colligitur, quantumvis occlusum est.

Elegantia huius methodi est ut unum alveum claudendo, alio canali uti desinas, ita alterum alveum oblique claudendo.

Sem III, M accipientium et N mittentium

Accipientem vel mittentem prope canalem habere non possumus, qui notitias tradendas adhibebat, nec unum ex multis receptoribus habere possumus, accessionem canalem significationis prope. Utrumque horum usuum principium clausurae canalis violant.

Sed inducere possumusIntermedium munus intermedium et additos canales significationis claudat ut omnes receptores et mittentes finis operis certiorem faciat.。

Exemplum codicis:

  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. }

Personal profile

technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones in technologia progressus ad futuram referentiam

mihi contactus notitia

Mail