Wat is het verschil tussen een proces en een thread?

Wat is het technische verschil tussen een proces en een thread?

Ik heb het gevoel dat een woord als ‘proces’ te veel wordt gebruikt en dat er ook hardware- en softwarethreads zijn. Hoe zit het met lichtgewicht processen in talen als Erlang? Is er een definitieve reden om de ene term boven de andere te gebruiken?

Antwoord 1, autoriteit 100%

Zowel processen als threads zijn onafhankelijke uitvoeringsreeksen. Het typische verschil is dat threads (van hetzelfde proces) in een gedeelde geheugenruimte worden uitgevoerd, terwijl processen in afzonderlijke geheugenruimten worden uitgevoerd.

Ik weet niet zeker naar welke “hardware” versus “software”-threads u verwijst. Threads zijn een functie voor de besturingsomgeving, in plaats van een CPU-functie (hoewel de CPU doorgaans bewerkingen heeft die threads efficiënt maken).

Erlang gebruikt de term “proces” omdat het geen model voor multiprogrammering met gedeeld geheugen blootlegt. Ze “threads” noemen zou impliceren dat ze een gedeeld geheugen hebben.

Antwoord 2, autoriteit 55%

Proces
Elk proces biedt de middelen die nodig zijn om een programma uit te voeren. Een proces heeft een virtuele adresruimte, uitvoerbare code, open handvatten voor systeemobjecten, een beveiligingscontext, een unieke proces-ID, omgevingsvariabelen, een prioriteitsklasse, minimale en maximale werksetgroottes en ten minste één uitvoeringsdraad. Elk proces wordt gestart met een enkele thread, vaak de primaire thread genoemd, maar kan extra threads maken van elk van zijn threads.

Draad
Een thread is een entiteit binnen een proces die kan worden gepland voor uitvoering. Alle threads van een proces delen de virtuele adresruimte en systeembronnen. Bovendien onderhoudt elke thread uitzonderingshandlers, een planningsprioriteit, lokale threadopslag, een unieke thread-ID en een reeks structuren die het systeem zal gebruiken om de threadcontext op te slaan totdat deze is gepland. De threadcontext omvat de set machineregisters van de thread, de kernelstack, een thread-omgevingsblok en een gebruikersstack in de adresruimte van het threadproces. Threads kunnen ook hun eigen beveiligingscontext hebben, die kan worden gebruikt voor het imiteren van klanten.

Deze informatie is gevonden in Microsoft Docs hier: Over processen en discussielijnen

Microsoft Windows ondersteunt preventieve multitasking, wat het effect creëert van gelijktijdige uitvoering van meerdere threads van meerdere processen. Op een computer met meerdere processors kan het systeem tegelijkertijd zoveel threads uitvoeren als er processors op de computer zijn.

Antwoord 3, autoriteit 20%

Proces:

• Een uitvoerende instantie van een programma wordt een proces genoemd.
• Sommige besturingssystemen gebruiken de term ‘taak’ om te verwijzen naar een programma dat wordt uitgevoerd.
• Een proces wordt altijd opgeslagen in het hoofdgeheugen, ook wel het primaire geheugen of random access memory genoemd.
• Daarom wordt een proces een actieve entiteit genoemd. Het verdwijnt als de machine opnieuw wordt opgestart.
• Er kunnen verschillende processen aan hetzelfde programma zijn gekoppeld.
• Op een systeem met meerdere processors kunnen meerdere processen parallel worden uitgevoerd.
• Op een systeem met één processor, hoewel echt parallellisme niet wordt bereikt, wordt een procesplanningsalgoritme toegepast en is de processor gepland om elk proces één voor één uit te voeren, wat een illusie van gelijktijdigheid oplevert.
• Voorbeeld:Meerdere exemplaren van het programma ‘Calculator’ uitvoeren. Elk van de instanties wordt een proces genoemd.

Thread:

• Een thread is een subset van het proces.
• Het wordt een ‘lichtgewicht proces’ genoemd, omdat het vergelijkbaar is met een echt proces, maar wordt uitgevoerd binnen de context van een proces en dezelfde bronnen deelt die door de kernel aan het proces zijn toegewezen.
• Meestal heeft een proces maar één besturingsdraad: één set machine-instructies die tegelijk worden uitgevoerd.
• Een proces kan ook bestaan uit meerdere uitvoeringsthreads die gelijktijdig instructies uitvoeren.
• Meerdere besturingsthreads kunnen het ware parallellisme benutten dat mogelijk is op systemen met meerdere processors.
• Op een systeem met één processor wordt een algoritme voor threadplanning toegepast en de processor is gepland om elke thread één voor één uit te voeren.
• Alle threads die binnen een proces draaien, delen dezelfde adresruimte, bestandsdescriptors, stack en andere procesgerelateerde attributen.
• Omdat de threads van een proces hetzelfde geheugen delen, wordt het synchroniseren van de toegang tot de gedeelde gegevens binnen het proces ongekend belangrijk.

Ik heb bovenstaande informatie geleend van de Kenniszoektocht! blog.

Antwoord 4, autoriteit 10%

Laten we eerst eens kijken naar het theoretische aspect. Je moet begrijpen wat een proces conceptueel is om het verschil te begrijpen tussen een proces en een thread en wat er tussen hen wordt gedeeld.

We hebben het volgende in sectie 2.2.2 Het klassieke draadmodelvan Moderne besturingssystemen 3edoor Tanenbaum:

Het procesmodel is gebaseerd op twee onafhankelijke concepten: resource
groeperen en uitvoeren. Soms is het handig om ze te scheiden;
dit is waar discussies binnenkomen….

Hij vervolgt:

Een manier om naar een proces te kijken is dat het een manier is om
groep gerelateerde bronnen samen. Een proces heeft een adresruimte
met programmatekst en -gegevens, evenals andere bronnen. Deze
bron kan open bestanden, onderliggende processen, openstaande alarmen,
signaalbehandelaars, boekhoudinformatie en meer. Door ze te plaatsen
samen in de vorm van een proces, kunnen ze gemakkelijker worden beheerd.
Het andere concept dat een proces heeft, is meestal een uitvoeringsdraad
ingekort tot gewoon draad. De draad heeft een programmateller die houdt
bijhouden welke instructie als volgende moet worden uitgevoerd. Het heeft registers, die
zijn huidige werkvariabelen behouden. Het heeft een stapel, die de bevat
uitvoeringsgeschiedenis, met één frame voor elke aangeroepen procedure maar niet
toch van teruggekomen. Hoewel een thread in een bepaald proces moet worden uitgevoerd, is de
draad en zijn proces zijn verschillende concepten en kunnen worden behandeld
afzonderlijk. Processen worden gebruikt om resources te groeperen; draden
zijn de entiteiten die gepland zijn voor uitvoering op de CPU.

Verder geeft hij de volgende tabel:

Per process items             | Per thread items
------------------------------ | -----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

Laten we het probleem hardware multithreadingoplossen. Klassiek zou een CPU een enkele uitvoeringsthread ondersteunen, waarbij de status van de thread wordt gehandhaafd via een enkele programmateller(PC), en een set registers. Maar wat gebeurt er als er een cache mist? Het duurt lang om gegevens uit het hoofdgeheugen op te halen, en terwijl dat gebeurt, zit de CPU daar gewoon inactief. Dus iemand had het idee om in principe twee sets threadstatus (PC + registers) te hebben, zodat een andere thread (misschien in hetzelfde proces, misschien in een ander proces) werk gedaan kan krijgen terwijl de andere thread op het hoofdgeheugen wacht. Er zijn meerdere namen en implementaties van dit concept, zoals Hyper-threadingen gelijktijdige multithreading(kortweg SMT).

Laten we nu eens kijken naar de softwarekant. Er zijn in principe drie manieren waarop threads aan de softwarekant kunnen worden geïmplementeerd.

1. Gebruikersruimtethreads
2. Kernelthreads
3. Een combinatie van beide

Alles wat u nodig hebt om draden uit te voeren, is de mogelijkheid om de CPU-staat op te slaan en meerdere stapels te onderhouden, die in veel gevallen in gebruiksruimte kunnen worden gedaan. Het voordeel van de threads voor de gebruiker is Super Fast Thread Switching, omdat u niet in de kernel hoeft te vissen en de mogelijkheid om uw threads in te plannen zoals u wilt. Het grootste nadeel is het onvermogen om te blokkeren I / O (die het hele proces en alle gebruikersdraden zou blokkeren), wat een van de grote redenen is die we in de eerste plaats draden gebruiken. Blokkeren I / O met behulp van draden vereenvoudigt het programma-ontwerp in veel gevallen aanzienlijk.

Kernel-threads hebben het voordeel dat het blokkerende I / O kan gebruiken, naast het verlaten van alle planningskwesties aan het besturingssysteem. Maar elke draadschakelaar vereist het vangen in de kernel die potentieel relatief traag is. Als u echter draden schakelt vanwege geblokkeerde I / O, is dit echter niet echt een probleem, omdat de I / O-operatie waarschijnlijk al in de kernel in de kernel in de kernel in de kernel zit.

Een andere aanpak is om de twee te combineren, met meerdere kerneldraden die elk meerdere gebruikersdraden hebben.

Dus terug naar uw vraag van terminologie, kunt u zien dat een proces en een uitvoeringsdraad twee verschillende concepten zijn en uw keuze van welke term om te gebruiken, hangt af van waar u het over hebt. Wat betreft de term “lichtgewichtproces”, zie ik het niet persoonlijk het punt erin, omdat het niet echt overbrengt wat er aan de hand is, evenals de term “thread of executie”.

5, Autoriteit 8%

Om meer uit te leggen met betrekking tot gelijktijdige programmering

1. Een proces heeft een zelfstandige uitvoeringsomgeving. Een proces heeft in het algemeen een complete, particuliere reeks basisrun-time-bronnen; In het bijzonder heeft elk proces zijn eigen geheugenruimte.

2. Draden bestaan binnen een proces — elk proces heeft er minstens één. Threads delen de bronnen van het proces, inclusief geheugen en geopende bestanden. Dit zorgt voor efficiënte, maar potentieel problematische, communicatie.

Een voorbeeld waarbij de gemiddelde persoon in gedachten wordt gehouden:

Op uw computer opent u Microsoft Word en een webbrowser. We noemen deze twee processen.

In Microsoft Word typt u iets en het wordt automatisch opgeslagen. Nu heb je gezien dat bewerken en opslaan parallel gebeuren – bewerken op de ene thread en opslaan op de andere thread.

Antwoord 6, autoriteit 4%

Een applicatie bestaat uit een of meer processen. Een proces is, in de eenvoudigste bewoordingen, een uitvoerend programma. Een of meer threads worden uitgevoerd in de context van het proces. Een thread is de basiseenheid waaraan het besturingssysteem processortijd toewijst. Een thread kan elk deel van de procescode uitvoeren, inclusief delen die momenteel door een andere thread worden uitgevoerd. Een vezel is een uitvoeringseenheid die handmatig moet worden gepland door de toepassing. Fibers worden uitgevoerd in de context van de threads die ze plannen.

Gestolen van hier.

Antwoord 7, autoriteit 2%

Een proces is een verzameling code, geheugen, gegevens en andere bronnen. Een thread is een reeks code die wordt uitgevoerd binnen de reikwijdte van het proces. U kunt (meestal) meerdere threads tegelijkertijd laten uitvoeren binnen hetzelfde proces.

Antwoord 8, autoriteit 2%

Voorbeeld uit de praktijk voor Process en Thread
Dit geeft je het basisidee over draad en proces

Ik heb de bovenstaande informatie geleend van het antwoord van Scott Langham– bedankt

Antwoord 9, autoriteit 2%

Proces:

1. Proces is een zwaar proces.
2. Proces is een afzonderlijk programma met afzonderlijk geheugen, gegevens, bronnen enz.
3. Proces worden gemaakt met de fork()-methode.
4. Context wisselen tussen het proces is tijdrovend.
   

Voorbeeld:
Zeg, het openen van een browser (mozilla, Chrome, IE). Op dit punt begint een nieuw proces uit te voeren.

Draden:

1. Draden zijn lichtgewicht processen. Draden zijn gebundeld in het proces.
2. Draden hebben een gedeeld geheugen, gegevens, bronnen, bestanden enz.
3. Threads worden gemaakt met de clone()-methode.
4. Contextwisseling tussen de threads kost niet veel tijd als proces.

Antwoord 10, autoriteit 2%

• Elk proces is een draad (primaire draad).
• Maar elke thread is geen proces. Het is een onderdeel (entiteit) van een proces.

Antwoord 11

Zowel threads als processen zijn atomaire eenheden van OS-resourcetoewijzing (d.w.z. er is een gelijktijdigheidsmodel dat beschrijft hoe de CPU-tijd ertussen wordt verdeeld, en het model van het bezit van andere OS-resources). Er is een verschil in:

• Gedeelde bronnen (threads delen per definitie geheugen, ze bezitten niets behalve stack en lokale variabelen; processen kunnen ook geheugen delen, maar daar is een apart mechanisme voor, onderhouden door OS)
• Toewijzingsruimte (kernelruimte voor processen versus gebruikersruimte voor threads)

Greg Hewgill hierboven had gelijk over de Erlang-betekenis van het woord “proces”, en hieris er een discussie over waarom Erlang processen lichtgewicht zou kunnen doen.

Antwoord 12

proberen deze vraag te beantwoorden met betrekking tot Java World.

Een proces is een uitvoering van een programma, maar een draad is een enkele uitvoeringsvolgorde in het proces. Een proces kan meerdere draden bevatten. Een draad wordt soms een lichtgewicht proces genoemd.

Bijvoorbeeld:

Voorbeeld 1:
Een JVM draait in een enkel proces en draden in een JVM delen de hoop die tot dat proces behoort. Daarom hebben verschillende threads toegang tot hetzelfde object. Threads delen de heap en hebben hun eigen stapelruimte. Dit is hoe de aanroeping van een thread van een methode en de lokale variabelen worden gehouden van draad veilig van andere draden. Maar de hoop is geen draadveilig en moet worden gesynchroniseerd voor draadveiligheid.

Voorbeeld 2:
Een programma kan mogelijk geen foto’s maken door toetsaanslagen te lezen. Het programma moet zijn volle aandacht geven aan de toetsenbordinvoer en het vermogen om meer dan één evenement tegelijk te hanteren, zal tot problemen leiden. De ideale oplossing voor dit probleem is de naadloze uitvoering van twee of meer secties van een programma op hetzelfde moment. Threads stelt ons in staat dit te doen. Hier is het tekenen van foto’s een proces en het lezen van toetsaanslag is subproces (draad).

13

Beide processen als threads zijn onafhankelijke uitvoeringssequenties. Het typische verschil is dat threads (van hetzelfde proces) in een gedeelde geheugenruimte lopen, terwijl processen in afzonderlijke geheugenruimten worden uitgevoerd.

proces

is een programma in uitvoering. Het heeft tekstgedeelte I.E de programmacode, de huidige activiteit zoals vertegenwoordigd door de waarde van programmeercounter & amp; Inhoud van processors registreren. Het bevat ook de processtapel die tijdelijke gegevens bevat (zoals functieparameters, return-adres en lokale variabelen) en een gegevenssectie, die globale variabelen bevat. Een proces kan ook een hoop bevatten, die het geheugen is dat dynamisch wordt toegewezen tijdens de tijdrun.

Discussie

Een draad is een basiseenheid van CPU-gebruik; Het omvat een draad-ID, een programmateller, registreerset en een stapel. Het heeft gedeeld met andere threads die behoren tot hetzelfde proces zijn codelgedeelte, gegevenssectie en andere besturingssystemen, zoals open bestanden en signalen.

– Uitgenomen van het besturingssysteem van Galvin

14

Voor degenen die comfortabeler zijn met het leren door visualiseren, is hier een handig diagram dat ik heb gemaakt om het proces en de draden te verklaren.
Ik gebruikte de informatie van MSDN – over processen en threads

15

Probeer het te beantwoorden van het OS-weergave van Linux Kernel

Een programma wordt een proces wanneer het in het geheugen wordt gestart. Een proces heeft zijn eigen adresruimte, wat betekent dat het verschillende segmenten in het geheugen heeft, zoals het segment .textvoor het opslaan van gecompileerde code, .bssvoor het opslaan van niet-geïnitialiseerde statische of globale variabelen, enz. < br>Elk proces zou zijn eigen programmateller en gebruikersruimte stackhebben.

Binnen de kernel zou elk proces zijn eigen kernelstack hebben (die voor beveiligingsproblemen is gescheiden van de gebruikersruimtestack) en een structuur met de naam task_structdie over het algemeen wordt geabstraheerd als het procesbesturingsblok , waarin alle informatie over het proces wordt opgeslagen, zoals de prioriteit, status (en een heleboel andere delen).
Een proces kan meerdere uitvoeringsdraden hebben.

Als ze naar threads gaan, bevinden ze zich in een proces en delen ze de adresruimte van het bovenliggende proces samen met andere bronnen die kunnen worden doorgegeven tijdens het maken van een thread, zoals bestandssysteembronnen, het delen van wachtende signalen, het delen van gegevens (variabelen en instructies), waardoor threads lichtgewicht en dus snellere contextwisseling mogelijk.

Binnen de kernel heeft elke thread zijn eigen kernelstack samen met de task_struct-structuur die de thread definieert. Daarom ziet de kernel threads van hetzelfde proces als verschillende entiteiten en zijn ze op zichzelf in te plannen. Threads in hetzelfde proces delen een gemeenschappelijk ID genaamd threadgroep-ID(tgid), en ze hebben ook een uniek ID genaamd het proces-ID (pid).

Antwoord 16

1. Een thread wordt uitgevoerd in een gedeelde geheugenruimte, maar een proces wordt uitgevoerd in een afzonderlijke geheugenruimte
2. Een draad is een lichtgewicht proces, maar een proces is een zwaar proces.
3. Een thread is een subtype van een proces.

Antwoord 17

Verschil tussen thread en proces?

Een proces is een uitvoeringsinstantie van een toepassing en een thread is een uitvoeringspad binnen een proces. Een proces kan ook meerdere threads bevatten. Het is belangrijk op te merken dat een thread alles kan doen wat een proces kan doen. Maar aangezien een proces uit meerdere threads kan bestaan, kan een thread als een ‘lichtgewicht’ proces worden beschouwd. Het essentiële verschil tussen een draad en een proces is dus het werk dat elk wordt gebruikt om te volbrengen. Threads worden gebruikt voor kleine taken, terwijl processen worden gebruikt voor meer ‘zware’ taken – in feite de uitvoering van applicaties.

Een ander verschil tussen een thread en een proces is dat threads binnen hetzelfde proces dezelfde adresruimte delen, terwijl verschillende processen dat niet doen. Hierdoor kunnen threads lezen van en schrijven naar dezelfde datastructuren en variabelen, en wordt ook de communicatie tussen threads vergemakkelijkt. Communicatie tussen processen – ook wel IPC of interprocescommunicatie genoemd – is vrij moeilijk en vergt veel middelen.

Hier is een samenvatting van de verschillen tussen threads en processen:

1. Threads zijn gemakkelijker te maken dan processen, omdat ze
   geen aparte adresruimte nodig.

2. Multithreading vereist zorgvuldige programmering sinds threads
   gegevensstructuren delen die slechts door één thread mogen worden gewijzigd
   tegelijk. In tegenstelling tot threads delen processen niet hetzelfde
   adresruimte.

3. Draden worden als lichtgewicht beschouwd omdat ze veel verbruiken
   minder middelen dan processen.

4. Processen zijn onafhankelijk van elkaar. Draden, omdat ze
   dezelfde adresruimte delen, zijn onderling afhankelijk, dus let op
   moeten worden genomen zodat verschillende threads niet op elkaar gaan staan.
   Dit is echt een andere manier om #2 hierboven te vermelden.

5. Een proces kan uit meerdere threads bestaan.

Antwoord 18

Vanuit het oogpunt van een interviewer zijn er eigenlijk maar drie belangrijke dingen die ik wil horen, naast voor de hand liggende dingen zoals een proces dat meerdere threads kan hebben:

1. Threads delen dezelfde geheugenruimte, wat betekent dat een thread toegang heeft tot het geheugen van andermans threadgeheugen. Processen kunnen dat normaal gesproken niet.
2. Bronnen. Bronnen (geheugen, handvatten, sockets, enz.) worden vrijgegeven bij het beëindigen van het proces, niet bij het beëindigen van de thread.
3. Beveiliging. Een proces heeft een vast beveiligingstoken. Een thread daarentegen kan zich voordoen als verschillende gebruikers/tokens.

Als je meer wilt, de reactie van Scott Langham omvat vrijwel alles.
Al deze zijn vanuit het perspectief van een besturingssysteem. Verschillende talen kunnen verschillende concepten implementeren, zoals taken, lichte threads enzovoort, maar het zijn slechts manieren om threads te gebruiken (van vezels op Windows).
Er zijn geen hardware- en softwarethreads. Er zijn uitzonderingenen interruptsvoor hardware en software, of threadsin gebruikersmodus en kernel.

Antwoord 19

Het volgende is wat ik kreeg uit een van de artikelen over The Code Project. Ik denk dat het alles duidelijk uitlegt.

Een thread is een ander mechanisme om de werklast in afzonderlijke delen te splitsen
uitvoeringsstromen. Een draad is lichter dan een proces. Dit
betekent dat het minder flexibiliteit biedt dan een volledig opgeblazen proces, maar kan:
sneller worden gestart omdat het besturingssysteem minder hoeft te
opgericht. Als een programma uit twee of meer threads bestaat,
threads delen een enkele geheugenruimte. Processen krijgen aparte adresruimten.
alle threads delen een enkele hoop. Maar elke thread krijgt zijn eigen stapel.

Antwoord 20

Proces:

Proces is in feite een programma in uitvoering. Het is een actieve entiteit.
Sommige besturingssystemen gebruiken de term ‘taak’ om te verwijzen naar een programma dat wordt uitgevoerd.
Een proces wordt altijd opgeslagen in het hoofdgeheugen, ook wel het primaire geheugen of random access memory genoemd.
Daarom wordt een proces een actieve entiteit genoemd. Het verdwijnt als de machine opnieuw wordt opgestart.
Er kunnen verschillende processen aan hetzelfde programma zijn gekoppeld.
Op een multiprocessorsysteem kunnen meerdere processen parallel worden uitgevoerd.
Op een systeem met één processor, hoewel echt parallellisme niet wordt bereikt, wordt een procesplanningsalgoritme toegepast en is de processor gepland om elk proces één voor één uit te voeren, wat een illusie van gelijktijdigheid oplevert.
Voorbeeld: Meerdere exemplaren van het programma ‘Calculator’ uitvoeren. Elk van de instanties wordt een proces genoemd.

Thread:

Een thread is een subset van het proces.
Het wordt een ‘lichtgewicht proces’ genoemd, omdat het vergelijkbaar is met een echt proces, maar wordt uitgevoerd binnen de context van een proces en dezelfde bronnen deelt die door de kernel aan het proces zijn toegewezen.
Gewoonlijk heeft een proces slechts één besturingsdraad: één set machine-instructies die tegelijk wordt uitgevoerd.
Een proces kan ook bestaan uit meerdere uitvoeringsdraden die gelijktijdig instructies uitvoeren.
Meerdere besturingsthreads kunnen het ware parallellisme benutten dat mogelijk is op systemen met meerdere processors.
Op een systeem met één processor wordt een algoritme voor threadplanning toegepast en is de processor gepland om elke thread één voor één uit te voeren.
Alle discussies die in een proces worden uitgevoerd, delen dezelfde adresruimte, bestandsdescriptoren, stapel en andere procesgerelateerde attributen.
Aangezien de threads van een proces hetzelfde geheugen delen, synchroniseren, synchroniseren van de toegang tot de gedeelde gegevens met het proces van het proces voor ongekend belang.

Ref- https://praktice.geeksforGeeks.org/problemen / Verschil-Tussen-proces-en-thread

21

Vanuit de ingebouwde wereld zou ik willen toevoegen dat het concept van processen alleen bestaat in “Big” -processors (Desktop CPUS, ARM CORTEX A-9 ) die MMU hebben (Memory Management Unit ) en besturingssystemen die ondersteunen met MMU’s (zoals Linux ). Met kleine / oude processors en microcontrollers en een klein RTOS-besturingssysteem (real-time besturingssysteem ), zoals Freertos, is er geen MMU-ondersteuning en dus geen processen, maar alleen threads.

Threads hebben toegang tot elkaar en ze zijn gepland door het besturingssysteem op een tussentijdse manier, zodat ze parallel lijken te rennen (of met multi-core die ze echt parallel lopen).

Processes , aan de andere kant, wonen in hun privé-sandbox van virtueel geheugen, verstrekt en bewaakt door MMU. Dit is handig omdat het in staat is:

1. Buggy-proces houden van het crashen van het hele systeem.
2. Beveiliging onderhouden door andere processen gegevens onzichtbaar en
   onbereikbaar.
   Het werkelijke werk in het proces wordt verzorgd door een of meer draden.

22

1. In principe is een draad een deel van een proces zonder procesdraad zou niet kunnen werken.
2. Een draad is lichtgewicht, terwijl het proces zwaargewicht is.
3. communicatie tussen processen vereist enige tijd, terwijl thread minder tijd kost.
4. Threads kunnen hetzelfde geheugengebied delen, terwijl processen gescheiden leven.

Antwoord 23

Proces: het programma dat wordt uitgevoerd staat bekend als proces

Thread: Thread is een functionaliteit die wordt uitgevoerd met het andere deel van het programma op basis van het concept “één met andere”, dus thread is een onderdeel van het proces..

Antwoord 24

Ik heb daar bijna alle antwoorden gelezen, maar als student die momenteel een OS-cursus volgt, kan ik de twee concepten helaas niet goed begrijpen. Ik bedoel, de meeste jongens lezen uit sommige OS-boeken de verschillen, d.w.z. threads hebben toegang tot globale variabelen in de transactie-eenheid, omdat ze gebruik maken van de adresruimte van hun proces. Toch rijst de nieuwe vraag waarom er processen zijn, we weten dat threads al lichter zijn dan processen. Laten we naar het volgende voorbeeld kijken door gebruik te maken van de afbeelding uit een van de eerdere antwoorden,

We hebben 3 threads die tegelijk aan een Word-document werken, b.v. Libre Office. De eerste controleert de spelling door te onderstrepen als het woord verkeerd is gespeld. De tweede neemt letters van het toetsenbord en drukt ze af. En de laatste bewaart het document in elke korte tijd om het document waaraan gewerkt is niet te verliezen als er iets misgaat. In dit geval kunnen de 3 threads geen 3 processen zijn, aangezien ze een gemeenschappelijk geheugen delen dat de adresruimte van hun proces is en dus allemaal toegang hebben tot het document dat wordt bewerkt.Dus de weg is het woord document samen met twee bulldozers die de draden zijn, hoewel een ervan ontbreekt in de afbeelding.

Antwoord 25

Tijdens het bouwen van een algoritme in Python (geïnterpreteerde taal) dat multi-threading bevatte, was ik verrast om te zien dat de uitvoeringstijd niet beter was in vergelijking met het sequentiële algoritme dat ik eerder had gebouwd. In een poging om de reden voor dit resultaat te begrijpen, heb ik wat gelezen, en ik geloof dat wat ik heb geleerd een interessante context biedt om de verschillen tussen multi-threading en multi-processen beter te begrijpen.

Multi-core systemen kunnen meerdere uitvoeringsthreads uitoefenen, en dus zou Python multi-threading moeten ondersteunen. Maar Python is geen gecompileerde taal en in plaats daarvan een geïnterpreteerde taal¹. Dit betekent dat het programma moet worden geïnterpreteerd om te kunnen worden uitgevoerd, en de interpreter is niet op de hoogte van het programma voordat het wordt uitgevoerd. Wat het echter wel weet, zijn de regels van Python en het past die regels vervolgens dynamisch toe. Optimalisaties in Python moeten dan voornamelijk optimalisaties zijn van de interpreter zelf, en niet de code die moet worden uitgevoerd. Dit in tegenstelling tot gecompileerde talen zoals C++, en heeft gevolgen voor multi-threading in Python. Python gebruikt in het bijzonder de Global Interpreter Lock om multithreading te beheren.

Aan de andere kant is een gecompileerde taal, nou ja, gecompileerd. Het programma wordt “volledig” verwerkt, waarbij het eerst wordt geïnterpreteerd volgens zijn syntactische definities, vervolgens wordt toegewezen aan een taalagnostische intermediaire representatie en ten slotte wordt gekoppeld aan een uitvoerbare code. Met dit proces kan de code sterk worden geoptimaliseerd omdat deze allemaal beschikbaar is op het moment van compilatie. De verschillende programma-interacties en relaties worden gedefinieerd op het moment dat het uitvoerbare bestand wordt gemaakt en robuuste beslissingen over optimalisatie kunnen worden genomen.

In moderne omgevingen moet de interpreter van Python multi-threading toestaan, en dit moet zowel veilig als efficiënt zijn. Dit is waar het verschil tussen een geïnterpreteerde taal en een gecompileerde taal in beeld komt. De interpreter mag intern gedeelde gegevens van verschillende threads niet verstoren, terwijl hij tegelijkertijd het gebruik van processors voor berekeningen optimaliseert.

Zoals in de vorige berichten is opgemerkt, zijn zowel een proces als een thread onafhankelijke sequentiële uitvoeringen met als belangrijkste verschil dat geheugen wordt gedeeld door meerdere threads van een proces, terwijl processen hun geheugenruimte isoleren.

In Python worden gegevens beschermd tegen gelijktijdige toegang door verschillende threads door de Global Interpreter Lock. Het vereist dat in elk Python-programma slechts één thread tegelijk kan worden uitgevoerd. Aan de andere kant is het mogelijk om meerdere processen uit te voeren, aangezien het geheugen voor elk proces is geïsoleerd van elk ander proces en processen op meerdere kernen kunnen draaien.

¹Donald Knuth heeft een goede uitleg van interpretatieve routines in The Art of Computer Programming: Fundamental Algorithms.

Antwoord 26

Threads binnen hetzelfde proces delen het geheugen, maar elke thread heeft zijn eigen stapel en registers, en threads slaan thread-specifieke gegevens op in de heap. Threads worden nooit onafhankelijk uitgevoerd, dus de communicatie tussen threads is veel sneller in vergelijking met communicatie tussen processen.

Processen delen nooit hetzelfde geheugen. Wanneer een onderliggend proces wordt gemaakt, wordt de geheugenlocatie van het bovenliggende proces gedupliceerd. Procescommunicatie wordt gedaan met behulp van pipe, gedeeld geheugen en berichtparsing. Het wisselen van context tussen threads is erg traag.

Antwoord 27

Het beste antwoord dat ik tot nu toe heb gevonden is Michael Kerrisk’s ‘The Linux Programming Interface’ ‘:

In moderne UNIX-implementaties kan elk proces meerdere threads hebben
van uitvoering. Een manier om threads voor te stellen is als een reeks processen
die hetzelfde virtuele geheugen delen, evenals een reeks andere
attributen. Elke thread voert dezelfde programmacode uit en wordt gedeeld
hetzelfde gegevensgebied en dezelfde heap. Elke thread heeft echter zijn eigen stapel
met lokale variabelen en informatie over functieaanroepen. [LPI 2.12]

Dit boek is een bron van grote duidelijkheid; Julia Evans noemde zijn hulp bij het opruimen hoe Linux-groepen echt werken in Dit artikel .

28

Voorbeeld 1: een JVM werkt in een enkel proces en draden in een JVM delen de hoop die tot dat proces behoort. Daarom hebben verschillende threads toegang tot hetzelfde object. Threads delen de heap en hebben hun eigen stapelruimte. Dit is hoe de aanroeping van een thread van een methode en de lokale variabelen worden gehouden van draad veilig van andere draden. Maar de hoop is geen draadveilig en moet worden gesynchroniseerd voor draadveiligheid.

29

Ze zijn bijna net zo hetzelfde … maar het sleutelverschil is een draad is lichtgewicht en een proces is zwaargewicht in termen van contextschakeling, werkbelasting enzovoort.