Även om jag vet har frågor om detta redan täckts (t.ex. https://stackoverflow.com/questions/5713142/green-threads-vs-non-green-threads ), jag känner inte att jag har ett tillfredsställande svar.
Frågan är: varför stöder JVM inte längre gröna trådar?
Det står detta i Java-stil FAQ-frågor :
En grön tråd avser ett driftsätt för Java Virtual Machine (JVM) där all kod körs i en enda operativsystemstråd.
Och detta slut på java.sun.com :
Nackdelen är att användning av gröna trådar innebär att systemtrådar på Linux inte utnyttjas och därför är den virtuella Java-maskinen inte skalbar när ytterligare processorer läggs till.
Det verkar för mig att JVM kan ha en pool av systemprocesser som är lika med antalet kärnor och sedan köra gröna trådar utöver det. Detta kan ge några stora fördelar när du har ett mycket stort antal trådar som blockerar ofta (mest för att nuvarande JVM ”s täcker antalet trådar).
Tankar?
Kommentarer
- För mig verkar frågan: Varför gröna trådar? Varför återinföra multithreading genom att emulera den på JVM-nivå via flera processer? Det ' mycket smärta och overhead för till synes ingen vinst annat än att låta programmerare vara mer generösa med lektrådar (och jag ' är inte övertygad om att ' är en fördel).
- Tja, det ' handlar om att ha en samtidig programmeringsmodell som skalas. För närvarande, i Java, om du vill ha skalbarhet du byter till NIO med din egen trådpool. Åtminstone att ' är min förståelse.
- Närvaron av saker som < akka.io > vilket antar rts lätta trådar får mig också att tro att det finns ett behov. Hittade faktiskt en ganska bra diskussion här < stackoverflow.com/questions/7458782/… >
- @delnan Eftersom kontextväxling för inbyggda trådar kostar. Gröna trådar har mycket mindre omkostnader för kontextväxling och interprocess-synkroniseringar. Dessutom är mängden gröna trådar praktiskt taget obegränsad (det kan vara hundratusentals av dem utan för mycket stress för VM-processen), medan mängden inbyggda trådar begränsas av operativsystem och minnesomkostnader.
- Det tog lång tid innan JVM stödde inbyggda trådar direkt. Gröna trådar var den mellanliggande lösningen fram till dess.
Svar
Jag minns att JVM övergav gröna trådar och flyttade till infödda trådar. Detta var av två enkla skäl: de gröna trådarna var uppriktigt sagt skräp, och det fanns ett behov av att stödja processorer med flera kärnor med den begränsade utvecklingsinsats som finns tillgänglig på Sun.
Detta var synd – gröna trådar ger mycket bättre abstraktion, vilket gör att samtidighet kan vara ett användbart verktyg och inte ett hinder. Men gröna trådar är ingen nytta om flera hinder inte kan övervinnas:
-
de måste använda alla de kärnor som är tillgängliga för dem
-
kontextbyte måste vara billig
-
I / O kan blockera alla trådar som är engagerade i den, men inte någon annan tråd och absolut inte alla andra trådar , vilket var fallet i vissa tidiga implementeringar.
Jag har ofta undrat varför multi-threading är så svårt i Java men det blir nu tydligare – det blev i slutändan att göra med övergången till inbyggda trådar, som är:
-
bra på att använda alla CPU-kärnor
-
bra på att vara riktigt samtidigt ger oberoende I / O etc
-
långsam vid kontextbyte (jämfört med de bästa implementeringarna av gröna trådar)
-
hemskt giriga med minne, och därmed begränsa det maximala användbara antalet av dem
-
en dålig abstraktion för vilken grund som helst för att uttrycka den verkliga världen, vilket naturligtvis är mycket samtidigt.
Numera är a mycket av programmerartiden går nu till att koda upp icke-blockerande I / O, futures etc. Det är synd att vi inte har en bättre abstraktionsnivå.
För jämförelse, förutom Erlang gör det nya Go -språket ett bra jobb med stor samtidighet. Farfar till dem alla förblir Occam , fortfarande ett pågående forskningsprojekt.
Kommentarer
- hur långt har vi gått sedan du postade: O
- Ack, Rust är ett annat språk som övergav bättre abstraktioner i samtidighet. De bestämde sig också för att gå från kooperativa trådar till ursprungliga trådar.
- @ Rick-777 Rost är för låg nivå för att göra det.
Svar
En enda process som fejkar flera trådar har många problem. En av dem är att alla falska trådar stannar vid sidfel.
Alternativet du föreslår, en pool av processer, har vissa fördelar och nackdelar. Den största fördelen, isolering av ”trådarna”, skulle verkligen inte ge dig mycket här. Den stora nackdelen, extrema svårigheter att implementera och mindre effektiv synkronisering, är deal-killer här.
Men jag håller med om att det finns vissa applikationer (inte Java) där en pool av processer som du kan använda som en pool av trådar (men med mer isolering) skulle vara bra att ha. Trådar delar i stort sett allt. Med processer kan du välj specifikt vad du vill dela. Så vitt jag vet har ingen försökt att genomföra det ännu.
Kommentarer
- Occam påstår sig erbjuda detta. Det var ett betydelsefullt språk på ' 80-talet, men led av brist på utvecklingsfinansiering och blev därför bara en forskningsnisch. Men dess idéer om samtidighet är lika solida nu som de var då och har ännu inte förbättrats.
- Om du är " flertrådad " al en golang (" M: N " typschemaläggning) blockeras då teoretiskt bara en grön tråd av ett sidfel eftersom de andra trådarna kan " plocka upp slacken " (andra gröna trådar) det verkar … softwareengineering.stackexchange.com/questions/222642/…
Svar
Det finns ingen fördel alls för en genomsnittlig Java-kod. Java är inte Erlang och Java-programmerare har inte samma inställning som Erlang-programmerare. Språket var aldrig avsett att användas på detta sätt.
Om du vill ha den verkliga lätta processen – använd Erlang och skapa tusentals trådar som kommunicerar via meddelanden. I Java kommer du att ha ett dussin trådar som delar ett gemensamt minne med mutexes och semaforer. Det är bara en annan programmeringsmodell, utformad för en annan uppsättning problem.
Kommentarer
- Så, för att klargöra det är det ett användbart tillvägagångssätt i Erlang. Och om man ignorerar problemen med Java-tankesättet kan det faktiskt hjälpa till?
- @redjamjar, det är osannolikt för att vara användbart i Java är själva språket inte riktigt lämpligt för en sådan användning, och dess huvudsakliga (och enda) fördel – den stora mängden färdiga bibliotek – vann ' väl in i en sådan främmande programmeringsmetod.
- Ja, om du vill ha den modellen, använd bara Erlang, det blir en storleksordning lättare
- Java! = JVM, säger bara 🙂
- @Bane, dessa " fördelar " finns bara om du ' har inget att jämföra