Wat is een “thread” (echt)?

Ik heb geprobeerd een goede definitie te vinden en inzicht te krijgen in wat een threadwerkelijk is.

Het lijkt erop dat ik iets voor de hand liggends moet missen, maar elke keer als ik lees wat een thread is, is het bijna een cirkelvormige definitie, a la “een thread is een uitvoeringsdraad” of “een manier om te verdelen in lopende taken “. Uhh. Huh?

Uit wat ik heb gelezen blijkt dat een thread niet echt ietsconcreet is, zoals een proces dat wel is. Het is eigenlijk maar een concept. Van wat ik begrijp van de manier waarop dit werkt, voert een processor enkele opdrachten uit voor een programma (dat een uitvoeringsdraadwordt genoemd), en wanneer het moet overschakelen naar verwerking voor een ander programma voor een bit, slaat het de statusop van het programma dat het momenteel uitvoert ergens (Thread Local Storage) en begint dan met het uitvoeren van de instructies van het andere programma. En heen en weer. Zodanig dat een thread eigenlijk slechts een concept is voor “een van de uitvoeringspaden” van een programma dat momenteel wordt uitgevoerd.

In tegenstelling tot een proces, dat echt iets is – het is een conglomeraat van middelen, enz.

Als voorbeeld van een definitie die me niet echt hielp . . .

Van Wikipedia:

“Een thread in de informatica is een afkorting voor een thread van uitvoering. Threads zijn een manier voor een programma om zichzelf te verdelen (genaamd “splitsen”) in twee of meer gelijktijdig (of pseudo-gelijktijdig) lopende taken. Threads en processen verschillen van het ene besturingssysteem tot het andere, maar over het algemeen bevindt een thread zich in een proces en verschillende threads in hetzelfde proces delen dezelfde bronnen, terwijl verschillende processen in hetzelfde multitasking-besturingssysteem dat niet doen.”

Dus ik heb gelijk? Mis? Wat is een thread eigenlijk?

Bewerken:Blijkbaar krijgt een thread ook een eigen call-stack, dus dat is een beetje een concreet ding.


Antwoord 1, autoriteit 100%

Een thread is een onafhankelijke set waarden voor de processorregisters (voor een enkele kern). Aangezien dit de instructiewijzer (ook bekend als programmateller) omvat, bepaalt deze wat er in welke volgorde wordt uitgevoerd. Het bevat ook de Stack Pointer, die beter naar een uniek geheugengebied voor elke thread kan wijzen, anders zullen ze met elkaar interfereren.

Threads zijn de software-eenheid die wordt beïnvloed door de besturingsstroom (functieaanroep, lus, goto), omdat die instructies werken op de instructiewijzer en die bij een bepaalde thread horen. Threads worden vaak gepland volgens een of ander prioriteringsschema (hoewel het mogelijk is om een systeem te ontwerpen met één thread per processorkern, in welk geval elke thread altijd actief is en er geen planning nodig is).

In feite is de waarde van de Instructiewijzer en de instructie die op die locatie is opgeslagen voldoende om een nieuwe waarde voor de Instructiewijzer te bepalen. Voor de meeste instructies verhoogt dit het IP gewoon met de grootte van de instructie, maar besturingsstroominstructies veranderen het IP op andere, voorspelbare manieren. De reeks waarden die het IP-adres aanneemt, vormt een uitvoeringspad dat door de programmacode weeft, waardoor de naam “thread” ontstaat.


Antwoord 2, autoriteit 91%

Een thread is een uitvoeringscontext, dat is alle informatie die een CPU nodig heeft om een stroom instructies uit te voeren.

Stel dat u een boek leest, en u wilt nu een pauze nemen, maar u wilt terugkomen en het lezen van het exacte punt te hervatten, waar u bent gestopt. Een manier om te bereiken, is door het paginanummer, het lijnnummer en het woordnummer op te lossen. Dus uw uitvoeringscontext voor het lezen van een boek is deze 3 nummers.

Als je een kamergenoot hebt, en ze gebruikt dezelfde techniek, kan ze het boek nemen terwijl je het niet gebruikt en het lezen van waar ze bent gestopt. Dan kun je het terugbrengen en het hervatten van waar je was.

Threads werken op dezelfde manier. Een CPU geeft je de illusie dat het tegelijkertijd meerdere berekeningen doet. Het doet dat door een beetje tijd op elke berekening door te brengen. Het kan dat doen omdat het een uitvoeringscontext voor elke berekening heeft. Net alsof je een boek met je vriend kunt delen, kunnen veel taken een CPU delen.

Op een meer technisch niveau bestaat een uitvoeringscontext (dus een draad) uit de waarden van de registers van de CPU.

Laatste: Threads zijn anders dan processen. Een draad is een context van uitvoering, terwijl een proces een aantal bronnen is die verband houden met een berekening. Een proces kan een of vele draden hebben.

Verduidelijking: de bronnen die aan een proces zijn gekoppeld, zijn geheugenpagina’s (alle threads in een proces hebben dezelfde weergave van het geheugen), bestandsdescriptoren (bijv. Open sockets) en beveiligingsreferenties (bijv. De ID van de gebruiker die het proces begon).


Antwoord 3, Autoriteit 36%

Om een ​​thread formeel te definiëren, moeten we eerst de grenzen begrijpen van waar een draad werkt.

Een computerprogramma wordt een proceswanneer het vanuit een bepaalde winkel in het geheugen van de computer wordt geladen en wordt uitgevoerd. Een proces kan worden uitgevoerd door een processor of een set processors. Een procesbeschrijving in het geheugen bevat vitale informatie zoals de programmateller die de huidige positie in het programma bijhoudt (d.w.z. welke instructie momenteel wordt uitgevoerd), registers, variabele opslag, bestandshandvatten, signalen, enzovoort.

Een threadis een reeks van dergelijke instructies binnen een programma die onafhankelijk van andere code kan worden uitgevoerd. De afbeelding toont het concept:

Threads bevinden zich binnen dezelfde procesadresruimte, dus veel van de informatie die aanwezig is in de geheugenbeschrijving van het proces kan over threads worden gedeeld.

Sommige informatie kan niet worden gerepliceerd, zoals de stapel (stapelaanwijzer naar een ander geheugengebied per thread), registers en threadspecifieke gegevens. Deze informatie is voldoende om threads onafhankelijk te kunnen plannenvan de hoofdthread van het programma en mogelijk een of meer andere threads binnen het programma.

Expliciete ondersteuning van het besturingssysteem is vereist om programma’s met meerdere threads uit te voeren. Gelukkig ondersteunen de meeste moderne besturingssystemen threads zoals Linux (via NPTL), BSD-varianten, Mac OS X, Windows, Solaris, AIX, HP-UX, enz. Besturingssystemen kunnen verschillende mechanismen gebruiken om multithreading-ondersteuning te implementeren.

Hiervind je meer informatie over het onderwerp. Dat was ook mijn informatiebron.

Laat me een zin toevoegen uit Inleiding tot Embedded Systemdoor Edward Leeen Seshia:

Threads zijn noodzakelijke programma’s die gelijktijdig worden uitgevoerd en een geheugenruimte delen. Ze hebben toegang tot elkaars variabelen. Veel beoefenaars in het veld gebruiken de term “threads” enger om te verwijzen naar specifieke manieren om programma’s te construeren die geheugen delen, [anderen] om in het algemeen te verwijzen naar elk mechanisme waarbij imperatieve programma’s gelijktijdig worden uitgevoerd en geheugen delen. In deze brede zin bestaan threads in de vorm van interrupts op bijna alle microprocessors, zelfs zonder enig besturingssysteem (kaal ijzer).


Antwoord 4, autoriteit 27%

Processen zijn als twee mensen die twee verschillende computers gebruiken, die het netwerk gebruiken om gegevens te delen wanneer dat nodig is. Discussies zijn als twee mensen die dezelfde computer gebruiken, die niet expliciet gegevens hoeven te delen, maar zorgvuldig om de beurt moeten zijn.

Conceptueel zijn threads slechts meerdere werkbijen die in dezelfde adresruimte zoemen. Elke thread heeft zijn eigen stapel, zijn eigen programmateller, enz., maar alle threads in een proces delen hetzelfde geheugen. Stel je voor dat twee programma’s tegelijkertijd draaien, maar ze hebben allebei toegang tot dezelfde objecten.

Vergelijk dit met processen. Processen hebben elk hun eigen adresruimte, wat betekent dat een aanwijzer in het ene proces niet kan worden gebruikt om naar een object in een ander proces te verwijzen (tenzij u gedeeld geheugen gebruikt).

Ik denk dat de belangrijkste dingen om te begrijpen zijn:

  • Zowel processen als threads kunnen “tegelijkertijd draaien”.
  • Processen delen geen geheugen (standaard), maar threads delen al hun geheugen met andere threads in hetzelfde proces.
  • Elke thread in een proces heeft zijn eigen stapel en zijn eigen instructiewijzer.

Antwoord 5, autoriteit 23%

Ik ga veel tekst uit het boek Operating Systems Concepts van ABRAHAM SILBERSCHATZ, PETER BAER GALVIN en GREG GAGNE gebruiken, samen met mijn eigen begrip van dingen.

Proces

Elke toepassing bevindt zich op de computer in de vorm van tekst (of code).

We benadrukken dat een programma op zich geen proces is. Een programma is een
passieve entiteit, zoals een bestand met een lijst met instructies die op schijf zijn opgeslagen
(vaak een uitvoerbaar bestand genoemd).

Als we een toepassing starten, maken we een uitvoeringsinstantie. Deze uitvoering wordt een proces genoemd.
EDIT: (Volgens mijn interpretatie, analoog aan een klasse en een instantie van een klasse, waarbij de instantie van een klasse een proces is. )

Een voorbeeld van processen is die van Google Chrome.
Wanneer we Google Chrome starten, worden 3 processen voortgebracht:

• Het browserproces is verantwoordelijk voor het beheren van de gebruikersinterface als
evenals schijf- en netwerk-I/O. Er wordt een nieuw browserproces gemaakt wanneer:
Chrome wordt gestart. Er wordt slechts één browserproces gemaakt.

Renderer-processen bevatten logica voor het weergeven van webpagina’s. Dus, zij
bevatten de logica voor het omgaan met HTML, Javascript, afbeeldingen, enzovoort.
Als algemene regel wordt voor elke website een nieuw rendererproces gemaakt
geopend in een nieuw tabblad, en dus kunnen verschillende rendererprocessen actief zijn
tegelijkertijd.

• Er wordt een plug-in-proces gemaakt voor elk type plug-in (zoals Flash
of QuickTime) in gebruik is. Plug-in processen bevatten de code voor de
plug-in en aanvullende code waarmee de plug-in kan
communiceren met de bijbehorende rendererprocessen en de browser
proces.

Draad

Om dit te beantwoorden, denk ik dat je eerst moet weten wat een processor is. Een processor is het stuk hardware dat de berekeningen daadwerkelijk uitvoert.
EDIT: (Berekeningen zoals het toevoegen van twee getallen, het sorteren van een array, in feite het uitvoeren van de code die is geschreven)

Ga nu verder met de definitie van een thread.

Een thread is een basiseenheid van CPU-gebruik; het bevat een thread-ID, een programma
teller, een registerset en een stapel.

EDIT: Definitie van een thread van de website van Intel:

Een thread, of uitvoeringsthread, is een softwareterm voor de geordende volgorde van instructies die kan worden doorgegeven aan of verwerkt door een enkele CPU-kern.

Dus als het Renderer-proces van de Chrome-applicatie een reeks getallen sorteert, vindt de sortering plaats op een thread/thread of uitvoering. (De grammatica met betrekking tot threads lijkt mij verwarrend)

Mijn interpretatie van dingen

Een proces is een uitvoeringsinstantie. Threads zijn de eigenlijke werkers die de berekeningen uitvoeren via CPU-toegang. Wanneer er meerdere threads worden uitgevoerd voor een proces, biedt het proces gemeenschappelijk geheugen.

BEWERKEN:
Andere informatie die ik nuttig vond om meer context te geven

Alle moderne computers hebben meer dan één thread. Het aantal threads in een computer hangt af van het aantal cores in een computer.

Concurrent Computing:

Van Wikipedia:

Concurrent computing is een vorm van computing waarbij verschillende berekeningen worden uitgevoerd tijdens overlappende tijdsperioden – gelijktijdig – in plaats van achter elkaar (de ene is voltooid voordat de volgende begint). Dit is een eigenschap van een systeem – dit kan een individueel programma, een computer of een netwerk zijn – en er is een afzonderlijk uitvoeringspunt of “controledraad” voor elke berekening (“proces”).

Ik zou dus een programma kunnen schrijven dat de som van 4 getallen berekent:

(1 + 3) + (4 + 5)

In het programma om deze som te berekenen (wat één proces zal zijn dat op een uitvoeringsthread wordt uitgevoerd) kan ik een ander proces dat op een andere thread kan worden uitgevoerd, splitsen om te berekenen (4 + 5) en het resultaat terug te sturen naar het oorspronkelijke proces , terwijl het oorspronkelijke proces de som van (1 + 3) berekent.


Antwoord 6, autoriteit 3%

Helaas bestaan er threads. Een draad is iets tastbaars. Je kunt er één doden, en de anderen zullen nog steeds rennen. Je kunt nieuwe threads spawnen…. hoewel elke thread niet zijn eigen proces is, worden ze afzonderlijk binnen het proces uitgevoerd. Op multi-core machines kunnen 2 threads tegelijkertijd worden uitgevoerd.

http://en.wikipedia.org/wiki/Simultaneous_multithreading

http://www.intel.com/intelpress/samples/mcp_samplech01.pdf


Antwoord 7, autoriteit 3%

Dit is overgenomen uit een Yahoo-antwoord:

Een thread is een codeerconstructie
onaangetast door de architectuur van een
sollicitatie. Een enkel proces
vaak kan meerdere bevatten
draden. Draden kunnen ook direct
met elkaar communiceren omdat ze
dezelfde variabelen delen.

Processen zijn onafhankelijke uitvoering
eenheden met hun eigen staat
informatie. Ze gebruiken ook hun eigen
adresruimten en kan alleen interageren
met andere processen door
communicatiemechanismen tussen processen.

Om het echter eenvoudiger te zeggen, zijn threads als verschillende “taken”. Denk dus aan wanneer u iets doet, u schrijft bijvoorbeeld een formule op één papier. Dat kan als één draad worden beschouwd. Dan is een andere draad dat je iets anders schrijft op een ander stuk papier. Dat is waar multitasking om de hoek komt kijken.

Intel-processors zouden “hyper-threading” hebben (AMD heeft het ook) en het is bedoeld om meerdere “threads” uit te voeren of veel beter te multitasken.

Ik ben niet zeker van de logistiek van hoe een thread wordt afgehandeld. Ik herinner me wel dat ik hoorde dat de processor heen en weer ging, maar ik ben hier niet 100% zeker van en hopelijk kan iemand anders daar antwoord op geven.


Antwoord 8, autoriteit 3%

Het antwoord varieert enormtussen verschillende systemen en verschillende implementaties, maar de belangrijkste onderdelen zijn:

  1. Een thread heeft een onafhankelijke uitvoeringsthread (d.w.z. je kunt er vanuit de context heen en weer schakelen, en het zal hervatten waar het was).
  2. Een thread heeft een levensduur (hij kan worden gemaakt door een andere thread en een andere thread kan wachten tot deze is voltooid).
  3. Er zit waarschijnlijk minder bagage aan vast dan een “proces”.

Bovendien: threads kunnen worden geïmplementeerd binnen een enkel proces door een taalruntime, threads kunnen coroutines zijn, threads kunnen worden geïmplementeerd binnen een enkel proces door een threading-bibliotheek, of threads kunnen een kernelconstructie zijn.

In verschillende moderne Unix-systemen, waaronder Linux waarmee ik het meest vertrouwd ben, is allesthreads — een proces is slechts een typethread die relatief weinig deelt dingen met zijn ouder (dwz het krijgt zijn eigen geheugentoewijzingen, zijn eigen bestandstabel en machtigingen, enz.) Het lezen van man 2 clone, vooral de lijst met vlaggen, is hier erg leerzaam.


Antwoord 9, autoriteit 3%

Een thread is niets meer dan een geheugencontext (of hoe Tanenbaum het beter zegt, resourcegroepering) met uitvoeringsregels. Het is een softwareconstructie. De CPU heeft geen idee wat een thread is (enkele uitzonderingen hier, sommige processors hebben hardwarethreads), het voert alleen instructies uit.

De kernel introduceert het thread- en procesconcept om het geheugen en de instructiesvolgorde op een zinvolle manier te beheren.


Antwoord 10

Een threadis een setvan (CPU)instructiesdie kan worden uitgevoerd.

Maar om beter te begrijpen wat een threadis, is enige kennis van computerarchitectuur vereist.

Een computer volgt instructies en manipuleert gegevens. RAMis de plaats waar de instructies en gegevens worden opgeslagen, de processor gebruikt die instructies om bewerkingen op de gegevens uit te voeren. De CPU bevat interne geheugencellen die registersworden genoemd. Die registers bevatten getallen waarop de CPU eenvoudige wiskundige bewerkingen uitvoert. Een voorbeeld kan het volgende zijn: “Voeg het nummer in register #3 toe aan het nummer in register #1.“.

De verzameling van alle bewerkingen die een CPU kan uitvoeren, wordt instructiesetgenoemd. Elke bewerking in de instructieset krijgt een nummer toegewezen en dat nummer wordt opgeslagen in RAM, dus computercode is in wezen een reeks cijfers die CPU-bewerkingen vertegenwoordigen.

De CPU werkt in een oneindige lus en haalt altijd een instructie op uit het geheugen en voert deze uit. De kern van deze cyclus is het PC-register, of Program Counter. Het is een speciaal register dat het geheugenadres opslaat van de volgende instructie die moet worden uitgevoerd.

De CPU zal:

  1. Haal de instructie op op het geheugenadres dat door de pc is opgegeven,
  2. Verhoog de pc met 1,
  3. Voer de instructie uit,
  4. Ga terug naar stap 1.

De CPU kan de opdracht krijgen om een nieuwe waarde naar de pc te schrijven, waardoor de uitvoering vertakt of naar ergens anders in het geheugen “springt”. En deze vertakking kan voorwaardelijk zijn. Een CPU-instructie zou bijvoorbeeld kunnen zeggen: “zet PC op adres #200 als register #1 gelijk is aan nul”. Hierdoor kunnen computers dit soort dingen uitvoeren:

if  x = 0
    compute_this()
else
    compute_that()

Bronnen gebruikt van Computer Science Distilled.

Other episodes