Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission. Læs mere.

På Linux kan du oprette og administrere tråde i C/C++ ved hjælp af POSIX-trådsbiblioteket (pthread). I modsætning til andre operativsystemer er der lille forskel mellem en tråd og en proces i Linux. Det er derfor, Linux ofte refererer til sine tråde som lette processer.

Ved at bruge pthread-biblioteket kan du oprette tråde, vente på, at de afsluttes, og afslutte dem eksplicit.

Historien om trådbrug på Linux

Før Linux version 2.6 var hovedtrådsimplementeringen LinuxThreads. Denne implementering havde betydelige begrænsninger med hensyn til ydeevne og synkroniseringsoperationer. En grænse for det maksimale antal tråde, der kunne køre, begrænsede dem til i 1000-tallet.

I 2003 lykkedes det et team ledet af udviklere fra IBM og RedHat at lave Native POSIX trådbibliotek (NPTL) projekt tilgængeligt. Den blev først introduceret i RedHat Enterprise version 3 for at løse ydeevneproblemer med Java Virtual Machine på Linux. I dag indeholder GNU C-biblioteket implementeringer af begge trådningsmekanismer.

instagram viewer

Ingen af ​​disse er en implementering af grønne tråde, som en virtuel maskine ville administrere og køre i rent brugertilstand. Når du bruger pthread-biblioteket, opretter kernen en tråd, hver gang et program starter.

Du kan finde trådspecifik information for enhver kørende proces i filerne under /proc//task. Dette er standardplaceringen for procesinformation under procfs Linux-standarden. For enkelt-tråds applikationer vil det se ud til, at der er en opgavepost med samme værdi som PID under denne mappe.

Arbejdslogik af tråde

Tråde er som processer, der i øjeblikket kører på operativsystemet. I enkeltprocessorsystemer (f.eks. mikrocontrollere) simulerer operativsystemkernen tråde. Dette gør det muligt for transaktioner at køre samtidigt gennem udskæring.

Et single-core operativsystem kan kun køre én proces ad gangen. Dog i multi-core eller multi-processor systemer, kan disse processer køre samtidigt.

Trådskabelse i C

Du kan bruge pthread_create funktion for at oprette en ny tråd. Det pthread.h header-filen inkluderer sin signaturdefinition sammen med andre tråd-relaterede funktioner. Tråde bruger det samme adresserum og filbeskrivelser som hovedprogrammet.

Pthread-biblioteket inkluderer også den nødvendige understøttelse af mutex og betingede operationer, der kræves til synkroniseringsoperationer.

Når du bruger funktionerne i pthread-biblioteket, skal du sikre dig, at compileren forbinder pthread bibliotek i din eksekverbare. Hvis det er nødvendigt, kan du instruere compileren til at linke til biblioteket ved hjælp af -l mulighed:

gcc -o prøve test_thread.c -lpthread

Funktionen pthread_create har følgende signatur:

intpthread_create(pthread_t *tråd, konstpthread_attr_t *attr, ugyldig *(*start_rutine)(ugyldig *), ugyldig *arg)

Det returnerer 0, hvis proceduren er vellykket. Hvis der er et problem, returnerer den en fejlkode, der ikke er nul. I ovenstående funktionssignatur:

  • Det tråd parameter er af typen pthread_t. Den oprettede tråd vil altid være tilgængelig med denne reference.
  • Det attr parameter lader dig angive tilpasset adfærd. Du kan bruge en række trådspecifikke funktioner startende med pthread_attr_ for at indstille denne værdi. Mulige tilpasninger er planlægningspolitikken, stakstørrelsen og frakoblingspolitikken.
  • start_rutine angiver den funktion, som tråden skal køre.
  • arg repræsenterer en generisk datastruktur videregivet til funktionen af ​​tråden.

Her er et eksempel på en applikation:

#omfatte
#omfatte
#omfatte
#omfatte

ugyldig *arbejder(ugyldig *data)
{
char *navn = (char*)data;

til (int i = 0; jeg < 120; i++)
{
søvn (50000);
printf("Hej fra trådnavn = %s\n", navn);
}

printf("Tråd %s udført!\n", navn);
Vend tilbageNUL;
}

intvigtigste(ugyldig)
{
pthread_t th1, th2;
pthread_create(&th1, NUL, arbejder, "X");
pthread_create(&th2, NUL, arbejder, "Y");
søvn(5);
printf("Forlader hovedprogrammet\n");
Vend tilbage0;
}

Trådtyper

Når en tråd vender tilbage fra hoved() funktion i en applikation, afsluttes alle tråde, og systemet frigør alle ressourcer, som programmet har brugt. Ligeledes, når du afslutter en tråd med en kommando som en Afslut(), vil dit program afslutte alle tråde.

Med pthread_join funktion, kan du i stedet vente på, at en tråd afsluttes. Tråden, der bruger denne funktion, vil blokere, indtil den forventede tråd afsluttes. De ressourcer, de bruger fra systemet, returneres ikke, selv i tilfælde som afslutning af tråde, der kan forbindes, uplanlagt af CPU'en eller endda undladt at forbinde med ptread_join.

Nogle gange er der situationer, hvor sammenføjning med pthread_join ikke giver mening; hvis det for eksempel er umuligt at forudsige, hvornår tråden slutter. I dette tilfælde kan du sikre, at systemet returnerer alle ressourcer automatisk på det punkt, hvor tråden vender tilbage.

For at opnå dette bør du starte de relevante tråde med LOVLIGGENDE status. Når du starter en tråd, LØSRIVE status kan indstilles via en tråd attribut værdier eller med pthread_detach fungere:

intpthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
intpthread_detach(pthread_t tråd);

Her er et eksempel på brug af pthread_join(). Udskift hovedfunktionen i det første program med følgende:

intvigtigste(ugyldig)
{
pthread_t th1, th2;
pthread_create(&th1, NUL, arbejder, "X");
pthread_create(&th2, NUL, arbejder, "Y");
søvn(5);
printf("forlader hovedprogrammet\n");
pthread_join (th1, NUL);
pthread_join (th2, NUL);
Vend tilbage0;
}

Når du kompilerer og kører programmet, vil dit output være:

Hej fra tråd Y
Hej fra tråd X
Hej fra tråd Y
...
Hej fra tråd Y
afslutter hovedprogrammet
Hej fra tråd X
...
Hej fra tråd X
Tråd X færdig!
Hej fra tråd Y
Tråd Y færdig!

Afslutning af tråd

Du kan annullere en tråd med et opkald til pthread_cancel og videregive den tilsvarende pthread_t id:

intpthread_cancel(pthread_t tråd);

Du kan se dette i aktion i den følgende kode. Igen, kun vigtigste Funktionen er anderledes:

intvigtigste(ugyldig)
{
pthread_t th1, th2;
pthread_create(&th1, NUL, arbejder, "X");
pthread_create(&th2, NUL, arbejder, "Y");
søvn(1);
printf("> Annullerer tråd Y!!\n");
pthread_cancel (th2);
søvn (100000);
printf("> Annullerer tråd X!\n");
pthread_cancel (th1);
printf("forlader hovedprogrammet\n");
Vend tilbage0;
}

Hvorfor oprettes tråde?

Operativsystemer forsøger altid at køre tråde på en eller flere CPU'er, enten fra en selvoprettet liste eller fra en brugeroprettet trådliste. Nogle tråde kan ikke køre, fordi de venter på et input/output signal fra hardwaren. De venter muligvis også frivilligt, venter på svar fra en anden tråd eller har en anden tråd, der blokerer dem.

Du kan justere de ressourcer, du allokerer til tråde, som du opretter ved hjælp af pthread. Dette kan være en brugerdefineret planlægningspolitik, eller du kan vælge planlægningsalgoritmer såsom FIFO eller Round-robin, hvis det ønskes.