Hoewel ik weet dat vragen hierover al zijn behandeld (bijv. https://stackoverflow.com/questions/5713142/green-threads-vs-non-green-threads ), heb ik niet het gevoel dat ik een bevredigend antwoord heb.

De vraag is: waarom ondersteunt JVM geen groene discussies meer?

Er staat dit op de code-stijl Java FAQ :

Een groene draad verwijst naar een werkingsmodus voor de Java Virtual Machine (JVM) waarin alle code wordt uitgevoerd in een enkele thread van het besturingssysteem.

En dit op java.sun.com :

Het nadeel is dat het gebruik van groene threads betekent dat er geen gebruik wordt gemaakt van systeemthreads op Linux en dat de virtuele Java-machine dus niet schaalbaar is wanneer er extra CPUs worden toegevoegd.

Het lijkt mij dat de JVM een pool van systeemprocessen kan hebben die gelijk is aan het aantal cores, en daarbovenop groene threads kan draaien. Dit kan een aantal grote voordelen bieden als je een zeer groot aantal threads hebt die vaak blokkeren (meestal omdat de huidige JVM het aantal threads beperkt).

Gedachten?

Reacties

  • Voor mij lijkt de vraag: waarom groene threads? Waarom multithreading opnieuw introduceren door het te emuleren op JVM-niveau via meerdere processen? Het ‘ veel pijn en overhead voor schijnbaar geen andere winst dan programmeurs toestaan genereuzer te zijn met spawning-threads (en ik ‘ ben er niet van overtuigd dat ‘ is een voordeel).
  • Nou, het ‘ gaat over het hebben van een gelijktijdige programmeermodel dat schaalbaar is. Momenteel, in Java, als je schaalbaarheid wilt je schakelt over naar NIO met je eigen threadpool. Tenminste, dat ‘ is mijn begrip.
  • De aanwezigheid van dingen als < akka.io > welke suppo rts lichtgewicht draden doen me ook denken dat er behoefte is. Ik heb hier eigenlijk een behoorlijk goede discussie gevonden < stackoverflow.com/questions/7458782/… >
  • @delnan Omdat context wisselen voor native threads kost. Groene discussies hebben veel minder overhead voor contextomschakeling en interprocessynchronisaties. Bovendien is het aantal groene threads praktisch onbeperkt (het kunnen er honderdduizenden zijn zonder al te veel stress voor het VM-proces), terwijl het aantal native threads wordt beperkt door OS en geheugenoverhead.
  • Het duurde lang voordat de JVM native threads direct ondersteunden. Groene discussies waren tot dan de tussenoplossing.

Antwoord

Ik herinner me dat de JVM de groene discussies verliet en verhuisde naar native threads. Dit was om twee eenvoudige redenen: de groene draden waren ronduit onzin, en er was behoefte aan ondersteuning van multi-core processors met de beperkte ontwikkelaarsinspanning die beschikbaar was bij Sun.

Dit was jammer – groene draden bieden een veel betere abstractie, waardoor concurrency een handig hulpmiddel is en geen struikelblok. Maar groene threads hebben geen zin als verschillende hindernissen “niet kunnen worden overwonnen:

  • ze moeten alle beschikbare cpu-kernen gebruiken

  • context switching moet goedkoop zijn

  • I / O mag elke thread die erin betrokken is blokkeren, maar niet enige andere thread en zeker niet alle andere threads , wat het geval was in sommige vroege implementaties.

Ik “heb me vaak afgevraagd waarom multi-threading zo moeilijk is in Java, maar het wordt nu duidelijker – het was uiteindelijk te maken met de omschakeling naar native threads, die:

  • goed zijn in het gebruik van alle cpu-kernen

  • goed zijn in echt zijn gelijktijdig, met onafhankelijke I / O enz.

  • traag bij het wisselen van context (vergeleken met de beste implementaties van groene discussies)

  • vreselijk hebzuchtig met geheugen, waardoor het maximaal bruikbare aantal ervan wordt beperkt.

  • een slechte abstractie voor elke basis voor het uitdrukken van de echte wereld, die natuurlijk sterk gelijktijdig is.

Tegenwoordig is een veel programmeurstijd gaat nu naar het coderen van niet-blokkerende I / O, futures enz. Het is een grote schande dat we geen beter abstractieniveau hebben.

Voor vergelijking, naast Erlang doet de nieuwe Go -taal goed werk van enorme gelijktijdigheid. De grootvader van allemaal blijft Occam , nog steeds een lopend onderzoeksproject.

Reacties

  • hoever zijn we gegaan sinds de tijd dat je het plaatste: O
  • Helaas, Rust is een andere taal die betere abstracties van gelijktijdigheid heeft opgegeven. Ook zij besloten om van coöperatieve threads over te gaan op native threads.
  • @ Rick-777 Rust is te laag niveau om dat te doen.

Antwoord

Een enkel proces dat meerdere threads vervalst, levert veel problemen op. Een daarvan is dat alle vervalste threads vastlopen bij elke paginafout.

Het alternatief dat u suggereert, een pool van processen, heeft enkele voor- en nadelen. Het grootste voordeel, de isolatie van de “threads”, zou je hier echt niet veel opleveren. Het grote nadeel, de extreme moeilijkheidsgraad van de implementatie en minder efficiënte synchronisatie, is de deal-killer hier.

Maar ik ben het er mee eens dat er enkele applicaties bestaan (niet Java) waar een pool van processen die je zou kunnen gebruiken als een pool van threads (maar met meer isolatie) geweldig zou zijn om te hebben. Threads delen vrijwel alles. Met processen kun je kies specifiek wat je wilt delen. Voor zover ik weet, heeft nog niemand de moeite genomen om het te implementeren.

Reacties

  • Occam beweert dit aan te bieden. Het was een belangrijke taal in de ‘ 80s, maar leed onder een gebrek aan ontwikkelingsfinanciering en werd bijgevolg alleen een onderzoeksniche. Maar de ideeën over gelijktijdigheid zijn nu net zo solide als toen en moeten nog worden verbeterd.
  • Als u ” multi-threaded ” al een golang (” M: N ” type planning), dan wordt in theorie slechts één groene draad geblokkeerd door een paginafout omdat de andere threads ” neem de speling op ” (andere groene discussies) het lijkt erop … softwareengineering.stackexchange.com/questions/222642/…

Antwoord

Er is helemaal geen voordeel voor een gemiddelde Java-code. Java is niet Erlang, en Java-programmeurs hebben niet dezelfde mentaliteit als Erlang-programmeurs. De taal was nooit bedoeld om op deze manier te worden gebruikt.

Als je de echte lichtgewicht processen wilt – gebruik Erlang en maak duizenden threads die communiceren via berichten. In Java heb je een dozijn threads die een gemeenschappelijk geheugen delen met mutexen en semaforen. Het is gewoon een ander programmeermodel, ontworpen voor een andere reeks problemen.

Opmerkingen

  • Dus, om te verduidelijken, het is een nuttige benadering in Erlang. En als je de problemen van de Java-mentaliteit negeert, zou het echt kunnen helpen?
  • @redjamjar, het is onwaarschijnlijk om bruikbaar te zijn in Java, is taal zelf niet helemaal geschikt voor een dergelijk gebruik, en het belangrijkste (en enige) voordeel ervan – de enorme hoeveelheid gebruiksklare bibliotheken – zal ‘ niet passen goed in zon buitenaardse programmeerbenadering.
  • Ja, als je dat model wilt, gebruik dan gewoon Erlang, het zal een orde van grootte gemakkelijker zijn
  • Java! = JVM, zeg maar 🙂
  • @Bane, deze ” voordelen ” bestaan alleen als je ‘ heb niets te vergelijken

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *