Cititorii ca tine ajută la sprijinirea MUO. Când efectuați o achiziție folosind link-uri de pe site-ul nostru, este posibil să câștigăm un comision de afiliat. Citeşte mai mult.

Contextul este una dintre caracteristicile critice din Go care permite concurența. În Go, „context” se referă la un pachet care oferă funcționalitate pentru valorile solicitate și semnalele de anulare peste granițele API.

Pachetul context funcționează simultan cu modelul de concurență Go, bazat pe conceptul de goroutine. Goroutinele sunt fire ușoare de execuție pe care le puteți crea și gestiona eficient, facilitând crearea de programe concurente în Go.

Pachetul Context

Pachetul context oferă funcționalitate pentru anularea funcțiilor de lungă durată sau lanțuri de apeluri întregi. Pachetul ajută, de asemenea, la stocarea valorilor din domeniul cererii pentru acces oriunde în lanțul de apeluri. Această caracteristică este la îndemână atunci când lucrați cu API-uri sau microservicii, unde cererile pot cuprinde mai multe apeluri de funcții și doriți să le anulați sau să le atașați anumite valori.

instagram viewer

Iată cum puteți importa pachetul de context în dvs Go programe.

import"context"

Funcțiile de context iau în Context tipul struct al pachetului de context. În mod convențional, ar trebui să utilizați ctx ca numele variabilei de instanță.

funcoperațiuni(context ctx. Context) {
}

Funcțiile pot returna tipul de structură Context pentru alte funcții și operații.

funcoperațiuni(context ctx. Context)context.Context {
}

Puteți crea un context nou cu A FACE funcția pachetului de context. Funcția TODO creează un nou context cu valoarea de context. Terminat(), un canal care se va închide la anularea contextului. Ar trebui să-l utilizați ca substituent atunci când aveți nevoie de un context, dar niciun context părinte nu este potrivit.

import"context"
funcprincipal() {
 ctx := context. A FACE()
}

Alternativ, fundal funcția creează un nou context fără valoare și un canal Done gol.

ctx := context. Fundal()

Ar trebui să utilizați funcția Background ca rădăcină a unui arbore context.

Context cu valori

Pachetul de context oferă funcționalitate pentru propagarea valorilor și semnalelor de anulare. Puteți utiliza valorile pentru informații de la datele din domeniul de aplicare al cererii până la semnalele de anulare și termenele limită.

Pachetul de context permite, de asemenea, crearea unui context copil moștenit din contextele părinte, permițând eficient manipularea valorilor și a semnalelor de anulare în cadrul unui program, deoarece puteți trece contextul prin multiple funcții.

Iată un exemplu de trecere a contextului prin funcții cu pachetul de context.

import (
"context"
)
funcvalorosContext(context ctx. Context)context.Context {
întoarcere context. CuValoare (ctx, "cheie de acces", "hfouneqcelkwfu")
}
funcreceiveContextData(context ctx. Context)orice {
 passKey := ctx. Valoare("cheie de acces")
întoarcere cheie de acces
}

The valorosContext funcția preia o instanță de context și returnează o instanță de context pentru următoarea funcție. Instanța de context este o valoare creată cu CuValoare metodă. Metoda WithValue preia instanța de context din funcție și o pereche cheie-valoare.

Pentru a prelua datele din context, va trebui să creați un nou context cu A FACE sau fundal funcția și transmiteți contextul funcției (în acest caz, valuableContext) și primiți contextul cu receiveContextData funcţie.

funcprincipal() {
 ctx := context. Fundal()
 ctx = valuableContext (ctx)
 fmt. Println (receiveContextData (ctx))
}

Variabila ctx este instanța de context din funcția Background. Funcția valuableContext preia variabila ctx și returnează contextul cu o valoare pe care funcția receiveContextData o preia și returnează valoarea din perechea cheie-valoare.

Context Timeouts și termene limită

The context pachetul oferă funcționalitate pentru setarea timeout-urilor și a termenelor limită în operațiuni. Stabilirea de timeout-uri și termene limită este utilă pentru operațiunile care trebuie să se recupereze.

Timeout-urile sunt durata unei operațiuni. Puteți seta un timeout pentru ca o operație să dureze 4 secunde; după aceea, contextul anulează cererea.

Pe de altă parte, un termen limită definește punctul absolut în care o operațiune ar trebui să se anuleze.

Puteți folosi WithTimeout metodă de a seta un timeout de context. Iată cum puteți seta un timeout de 2 secunde.

funcprincipal() {
 ctx, anulați := context. WithTimeout (context. Fundal(), 2 * timp. Al doilea)
amâna Anulare()
// o operațiune
}

The principal funcția creează un context cu un timeout de două secunde. Funcția WithTimeout returnează o funcție de anulare pe care o puteți amâna pentru anulare la ieșirea din funcția principală.

Puteți declara termene limită cu Cu Termen limită metodă. Metoda WithDeadline include o instanță de context și un termen limită.

funcFă ceva(context ctx. Context) {
 deadlineTime := timp. Acum().Adaugă(1500 * timp. milisecundă)
 ctx, ctxCancel := context. WithDeadline (ctx, deadlineTime)
amâna ctxCancel()
// o operațiune
 ctxCancel()
}

The Fă ceva funcția ia într-un context, iar termen limită variabilă este timpul înainte de context Termen limită. The ctx variabila este contextul cu un termen limită.

The ctxCancel variabila anulează contextul atunci când contextul își depășește termenul limită.

Cele mai bune practici pentru utilizarea contextelor în Go

Evitați utilizarea contextelor ca variabile globale. Utilizarea contextelor ca variabile globale poate duce la comportamente neașteptate ale codului și erori greu de urmărit și poate utiliza contextul cu moderație pentru a reduce complexitatea codului.

În cele din urmă, folosiți contextele ca semnale, nu garanții. Anularea unui context nu garantează că toate goroutinele vor înceta să ruleze; este doar un semnal, iar gorutinele sunt agnostice de contexte.