Een van de populairste aspecten van de programmeertaal Go is de eersteklas ondersteuning van het vermogen van een computer om vele taken tegelijk uit te voeren. Het vermogen om code gelijktijdig uit te voeren wordt steeds belangrijker bij het programmeren, omdat computers niet langer één enkele stroom code sneller uitvoeren, maar vele stromen tegelijk. Om programma's sneller te laten lopen, moeten programmeurs ze zo ontwerpen dat ze gelijktijdig kunnen draaien, zodat elk gelijktijdig element van het systeem onafhankelijk van de andere kan worden uitgevoerd.
Twee Go functionaliteiten, Goroutines, en kanalen maken gelijktijdigheid gemakkelijker wanneer ze samen worden gebruikt. Goroutines biedt het basistype voor deze mogelijkheid. Goroutines zijn minder duur wat betreft geheugenruimte, interactie tussen threads en netwerkconnectiviteit. Ze hebben ook een betere opstarttijd dan threads, die veel programmeertalen ondersteunen. In wezen verwijst Go naar Goroutines als wat Java en andere programmeertalen threads noemen.
Wat zijn Goroutines?
Een goroutine is een eenvoudige implementatie thread in Golang die gelijktijdig met de rest van het programma uitvoert. Goroutines zijn betaalbaar als ze lijken op standaard threads omdat de kosten voor het maken van een goroutine extreem laag zijn. Daarom worden ze veel gebruikt in Go voor gelijktijdige programmering. Elk programma bestaat uit ten minste één goroutine, de zogenaamde hoofdgoroutine. De hoofdgoroutine bestuurt alle andere goroutines; dus als de hoofdgoroutine eindigt, doen alle andere goroutines in het script dat ook. Goroutine is altijd actief op de achtergrond.
Voorbeeld: Hier is een illustratie: je bent iets aan het schrijven in je notebook en krijgt honger; je neemt een pauze en gaat wat eten. Daarna begint u weer te schrijven. U vervult nu twee rollen (schrijven en eten) door een tijdsvenster dat als gelijktijdig werk wordt beschouwd. Er zij op gewezen dat deze twee taken (schrijven en eten) nog steeds gelijktijdig moeten worden uitgevoerd. Wanneer items gelijktijdig worden voltooid, spreekt men van parallellisme (stel je voor dat je je gsm gebruikt terwijl je chips eet). Concurrency omvat interactie met vele dingen tegelijk. Parallellisme (veel dingen tegelijk uitvoeren) is een subklasse hiervan (hoeft niet tegelijkertijd uitgevoerd te worden) met een bepaald tijdschema.
We kunnen een goroutine toevoegen door het sleutelwoord go toe te passen op de functieaanroep. Zodra we het go sleutelwoord toepassen op de functieaanroep, stellen we de concurrency in op de prestatie. Maar laten we eerst het effect van het toepassen van het go sleutelwoord op de uitvoering vaststellen. Laten we overwegen dat er twee goroutines zijn in een programma. De tekst "package main import" wordt de ingang van het programma. In Go is een package main import een declaratieve importverklaring. De hoofdgoroutine (first goroutine) wordt geïmporteerd. Wanneer we go (f) uitvoeren, wordt de tweede goroutine gevormd (0). Gewoonlijk zal onze software elk commando in de hoofdfunctie uitvoeren wanneer we een functie uitvoeren voordat we naar de volgende regel gaan.
We kunnen de procedure snel uitvoeren met een goroutine voordat we naar de volgende stap gaan. Daarom is een scanln-methode toegevoegd; anders zou de code eindigen voordat alle getallen worden getoond. Goroutines is eenvoudig te maken en kan in grote aantallen worden gemaakt. U zult merken dat wanneer deze software wordt uitgevoerd, de goroutines achter elkaar lijken te werken in plaats van gelijktijdig.
Voordelen van Goroutines boven threads
Goroutines kosten weinig
Goroutines zijn minder duur dan andere processen. De massa is slechts een paar kilobytes groot, en het kan uitbreiden of inkrimpen om aan de eisen van het programma te voldoen, in tegenstelling tot threads, waarvan de stapelgrootte moet worden gedefinieerd en permanent is.
Er zijn gemultiplexte Goroutines
Er zijn zeer weinig besturingssysteemthreads waaraan ze gemultiplexed zijn. In een programma met honderden goroutines is er misschien maar één proces. De rest van de goroutines wordt overgedragen aan het nieuwe besturingssysteemproces. Stel dat een goroutine in dat proces vastloopt, bijvoorbeeld wanneer deze om tussenkomst van de gebruiker vraagt. De runtime beheert elk van deze zaken, en wij ontwikkelaars krijgen een duidelijke API om tegelijkertijd met deze subtiele fijne kneepjes om te gaan.
Goroutines communiceren met behulp van kanalen
Goroutines communiceren via kanalen. Bedoeld om race-situaties te voorkomen wanneer zij relevant geheugen delen. Kanalen kunnen worden vergeleken met een kanaal dat goroutines gebruiken om met elkaar te communiceren.
Wat zijn kanalen?
Twee goroutines kunnen met elkaar communiceren en hun werking coördineren via kanalen. Deze software zal voortdurend "ping" afdrukken. Om een kanaalvorm aan te duiden, wordt het voorvoegsel "chan" vergezeld van de items die op het kanaal worden uitgezonden." In dit geval gaat het om strings. Op het kanaal worden berichten verzonden en ontvangen met behulp van de operator. "ping" verwijst naar het verzenden van een "ping".
Een kanaal wordt gebruikt om de twee goroutines synchroon te houden. Voordat een bericht over het kanaal wordt verzonden, wacht de router tot de printer klaar is om het te accepteren. De term hiervoor is inhibitie. Bij het maken van een kanaal kan een tweede parameter worden gebruikt voor de make-functie: c:= make (chan int, 1)
De richting van het kanaal
We kunnen de richting van een kanaalvorm definiëren en deze parametreren om te ontvangen of te zenden. Het teken van de methode van Pinger, bijvoorbeeld, kan zo worden aangepast:
func pinger(c chan<- string)
C kan nu alleen verzonden worden. Ontvangen van c zal resulteren in een codefout. Evenzo kunnen we de uitgang wijzigen in:
func printer(c string -chan)
Een semi-kanaal heeft deze beperkingen niet. Een tweerichtingskanaal kan worden geleverd aan een procedure die alleen kanalen met alleen zenden of alleen accepteren accepteert, maar niet andersom.
Hoe maak je een goroutine?
De methode om een goroutine te starten is eenvoudig. Pas het sleutelwoord "go" toe op de functieaanroep om een goroutine te maken die gelijktijdig wordt uitgevoerd. Hier gaan we een goroutine maken. Stel dat we een programma hebben met twee functies: de ene is een welkomstfunctie en de andere is de hoofdfunctie.
Wanneer we een nieuwe goroutine maken, zal de welkom () code worden uitgevoerd naast de main() functie. Wanneer u dit programma uitvoert, zult u verrast zijn. Dit programma toont slechts de tekst van de hoofdfunctie. Wat gebeurde er met de eerste goroutine of nieuwe goroutine die we startten? Om te begrijpen waarom dit gebeurt, moeten we eerst de twee belangrijkste kenmerken van goroutines kennen.
- De goroutinefunctie reageert onmiddellijk wanneer we een nieuwe goroutine aanmaken. Afgezien van functies vertrouwt het beheer niet op de goroutine, dus wacht het niet tot deze zijn uitvoering heeft voltooid. De uitvoering wordt overgedragen aan het volgende blok code na de goroutinefunctie. Daarom worden eventuele parameters van de goroutine genegeerd.
- Eventuele extra goroutines moeten gelijktijdig met de primaire goroutine worden uitgevoerd. Als de hoofdgoroutine faalt, zal het programma stoppen, en geen extra goroutines draaien.
U begrijpt nu waarom onze code niet werkte. Na de aanroep van go welcome(), werd de controle overgebracht naar de volgende regel code, alvorens te wachten tot de hello goroutine voltooid was, en de hoofdfunctie werd uitgevoerd. De main goroutine stierf omdat er geen script was om uit te voeren, waardoor de hello goroutine niet kon draaien.
We riepen de slaaptechniek (time.sleep(1 * time.second)) in om de goroutine 1 seconde te pauzeren. De functie hello () heeft nu voldoende tijd om te voltooien voordat de hoofdgoroutine afslaat. Deze software schrijft eerst de "welcome goroutine" en wacht dan één seconde alvorens de hoofdfunctie af te drukken. We gebruiken de slaaptechniek in de primaire goroutine om deze even te pauzeren om de andere goroutines te laten voltooien.
Meerdere maken Goroutines
We gaan een ander programma starten om meerdere goroutines te maken. We kunnen beginnen met het maken van twee goroutines die parallel worden uitgevoerd. Deze twee goroutines zijn getallen goroutines[go numbers()] en alfabet goroutines [go alphabets ()].
De getallengoroutine blijft 250 ms staan voor het afdrukken van 1, rust opnieuw voor het afdrukken van 2, enzovoort tot het 5 produceert. Evenzo geeft de alfanumerieke goroutine de letter van a tot e weer en wacht dan 400 milliseconden. Tenslotte maakt de primaire goroutine de gehele getallen en alfanumerieke tekens en pauzeert even, waarna de hoofdgoroutine eindigt.
Veel voorkomende concurrent programmeerfouten
- Afwezigheid van synchronisaties wanneer dit nodig is
- Tijd gebruiken. Sleep-oproepen om synchronisaties te doen
- Laat goroutines bungelen kopieerwaarden van de types in het standaard sync pakket
- Roep de sync
- Wachtgroep
- Voeg methode toe op verkeerde plaatsen
- Gebruik kanalen als morgen sluiten, niet van de laatste functionele afzender goroutine
Conclusie
In dit artikel hebben we een programma ontwikkeld dat het sleutelwoord go gebruikte om één goroutine en meerdere goroutines te starten die gelijktijdig gehele getallen afdrukten. Na het starten van dat programma maakten we een nieuw kanaal aan, dat we vervolgens gebruikten om getallen te produceren in één goroutine en ze door te geven aan een andere goroutine zodat ze op het scherm konden worden weergegeven. Als laatste demonstratie van het starten van een goroutine om uw toepassingen op multi-core systemen te versnellen, startte u tegelijkertijd vele "drukkende" goroutines.
Zoals bekend zijn goroutines een manier om taken sneller en efficiënter uit te voeren. Dit is een van de inzetprocedures die AppMaster biedt om de functionaliteit van uw toepassing te verbeteren. Met AppMaster kunnen zelfs personen met weinig tot geen programmeerkennis taken uitvoeren die met handmatige codering een uitdaging zouden vormen.
AppMaster is een no-code platform dat zowel mobiele en webapplicaties als een backend kan creëren . Een interessant feit AppMaster creëert een backend door Go aan 22.000 lijnen per seconde en u heeft toegang tot de broncode.
