Grön tråd

I datorprogrammering är en grön tråd en tråd som är schemalagd av ett runtime-bibliotek eller virtuell maskin (VM) istället för av det underliggande operativsystemet (OS). Gröna trådar emulerar flertrådade miljöer utan att förlita sig på några inbyggda OS-förmågor, och de hanteras i användarutrymme istället för kärnutrymme , vilket gör att de kan arbeta i miljöer som inte har inbyggt trådstöd.

Etymologi

Gröna trådar hänvisar till namnet på det ursprungliga trådbiblioteket för programmeringsspråket Java (som släpptes i version 1.1 och sedan övergavs gröna trådar i version 1.3 till inhemska trådar). Den designades av The Green Team på Sun Microsystems .

Historia

Gröna trådar var kort tillgängliga i Java mellan 1997 och 2000

Gröna trådar delar en enda operativsystemtråd genom kooperativ samtidighet och kan därför inte uppnå parallella prestandavinster som operativsystemtrådar. Den största fördelen med koroutiner och gröna trådar är enkel implementering

Prestanda

På en flerkärnig processor kan inbyggda trådimplementeringar automatiskt tilldela arbete till flera processorer, medan green thread-implementeringar normalt inte kan. Gröna trådar kan startas mycket snabbare på vissa virtuella datorer. På enprocessordatorer har dock den mest effektiva modellen ännu inte fastställts klart.

Benchmarks på datorer som kör Linux-kärnan version 2.2 (släpptes 1999) har visat att:

Gröna trådar överträffar avsevärt Linux inbyggda trådar när det gäller trådaktivering och synkronisering .
Inbyggda Linux-trådar har något bättre prestanda på input/output (I/O) och kontextväxlingsoperationer .

När en grön tråd kör ett blockerande systemanrop, blockeras inte bara tråden, utan alla trådar i processen blockeras. För att undvika det problemet måste gröna trådar använda asynkrona I/O- operationer, även om den ökade komplexiteten på användarsidan kan minskas om den virtuella maskinen som implementerar de gröna trådarna skapar specifika I/O-processer (dolda för användaren) för varje I/O O operation. ^{[ citat behövs ]}

Det finns också mekanismer som tillåter användning av inbyggda trådar och minskar omkostnaderna för trådaktivering och synkronisering:

Trådpooler minskar kostnaden för att skapa en ny tråd genom att återanvända ett begränsat antal trådar.
Språk som använder virtuella maskiner och inbyggda trådar kan använda escape-analys för att undvika synkronisering av kodblock när det inte behövs.

Gröna trådar i den virtuella Java-maskinen

Ursprunglig implementering: Gröna trådar

I Java 1.1 var gröna trådar den enda trådningsmodellen som användes av Java Virtual Machine (JVM), åtminstone på Solaris . Eftersom gröna trådar har vissa begränsningar jämfört med inbyggda trådar, släppte efterföljande Java-versioner dem till förmån för infödda trådar.

Ett undantag från detta är den virtuella maskinen Squawk , som är en blandning mellan ett operativsystem för enheter med låg effekt och en virtuell Java-maskin. Den använder gröna trådar för att minimera användningen av inbyggd kod och för att stödja migrering av dess isolat.

Kilim och Quasar är projekt med öppen källkod som implementerar gröna trådar på senare versioner av JVM genom att modifiera Java-bytekoden som produceras av Java-kompilatorn (Quasar stöder även Kotlin och Clojure ).

Gröna trådar på andra språk

Det finns några andra programmeringsspråk som implementerar motsvarigheter till gröna trådar istället för infödda trådar. Exempel:

Chicken Scheme använder lätta trådar på användarnivå baserat på förstklassiga fortsättningar
.NET använder gröna trådar via uppgifter
Vanlig Lisp
CPython med greenlet , eventlet och gevent , PyPy
Crystal erbjuder fibrer
D erbjuder fibrer som används för asynkron I/O
Dyalog APL kallar dem trådar
Erlang
Gå
Haskell
Julia använder gröna trådar för sina uppgifter .
Limbo
Lua använder koroutiner för samtidighet. Lua 5.2 erbjuder också sann C coroutine semantik genom funktionerna lua_yieldk , lua_callk och lua_pcallk . CoCo - tillägget tillåter sann C coroutine semantik för Lua 5.1.
Nim tillhandahåller asynkron I/O och koroutiner
OKaml , sedan version 5.0, stöder gröna trådar genom Domainslib.Task -modulen
occam , som föredrar termen process istället för tråd på grund av dess ursprung i att kommunicera sekventiella processer
Perl stödjer gröna trådar genom koroutiner
PHP stöder gröna trådar genom fibrer och koroutiner
Ruby före version 1.9
Racket (infödda trådar finns också tillgängliga via Places)
Rust kör systemtrådar inbyggt; den stöder gröna trådar genom tredjepartsbibliotek som Tokio .
SML/NJ :s implementering av Concurrent ML
Smalltalk (de flesta dialekter: Squeak , VisualWorks, GNU Smalltalk , etc.)
Stackless Python stöder antingen förebyggande multitasking eller kooperativ multitasking genom mikrotrådar (kallade tasklets ).
Tcl har koroutiner och en händelseloop

Den virtuella maskinen Erlang har vad som kan kallas gröna processer – de är som operativsystemsprocesser (de delar inte tillstånd som trådar gör) utan är implementerade inom Erlang Run Time System (erts). Dessa kallas ibland gröna trådar , men har betydande skillnader ^{[ förtydligande behövs ]} från vanliga gröna trådar. ^{[ citat behövs ]}

I fallet med GHC Haskell sker en kontextväxling vid den första tilldelningen efter en konfigurerbar timeout. GHC-trådar körs också potentiellt på en eller flera OS-trådar under deras livstid (det finns ett många-till-många-förhållande mellan GHC-trådar och OS-trådar), vilket möjliggör parallellitet på symmetriska multiprocessmaskiner, samtidigt som man inte skapar dyrare OS-trådar än vad som behövs att köra på det tillgängliga antalet kärnor. ^{[ citat behövs ]}

occam är ovanligt i den här listan eftersom dess ursprungliga implementering gjordes för Transputer , och därför behövdes ingen virtuell maskin. Senare portar till andra processorer har introducerat en virtuell maskin som bygger på designen av transputern, ett effektivt val på grund av de låga omkostnaderna.

De flesta virtuella Smalltalk-maskiner räknar inte utvärderingssteg; dock kan den virtuella datorn fortfarande föregripa den exekverande tråden på externa signaler (såsom utgående timers eller att I/O blir tillgänglig). Vanligtvis round-robin-schemaläggning så att en högprioriterad process som vaknar regelbundet effektivt implementerar tidsdelningsföreträde :

     [ [(  Fördröjning  i millisekunder:  50  )  vänta  ]  upprepa  ]  forkAt:  Processor  högIOPriority

Andra implementeringar, t.ex. QKS Smalltalk, är alltid tidsdelning. Till skillnad från de flesta implementeringar av grön tråd, stöder QKS också förhindrande av prioritetsinvertering .

Se även

externa länkar

" Four for the ages ", JavaWorld- artikel om gröna trådar
Gröna trådar om Java-trådar FAQ