Introduktion:
I C, termen 'multithreading' beskriver användningen av många trådar samtidigt. Varje tråd gör en annan uppgift . På grund av den samtidiga karaktären av multithreading kan många uppgifter utföras på en gång. Dessutom, multitrådning minskar CPU:s resursanvändning . Det finns två kategorier av multitasking: processbaserad och trådbaserad . När något beskrivs som multithreading betyder det att minst två eller kanske flera trådar körs i samma process samtidigt. Vi måste först förstå vad en tråd och en process är för att förstå multithreading i C. Låt oss titta på dessa ämnen för att få en bättre förståelse.
innehåller java-metoden
Vad är processer och trådar?
A tråd är grundläggande byggnad blockera av alla processers utförande. Ett program är uppbyggt av flera processer, och varje process består av trådar, som är mycket mer grundläggande enheter. Därför kan tråden betraktas som den grundläggande byggstenen i en process eller den enklare enheten som gemensamt bestämmer CPU-användning.
Följande artiklar ingår i en tråd:
Tråd-ID:
Det är en speciell tråd-ID som genereras vid tidpunkten för trådbildning och behålls under den specifika trådens varaktighet.
Programräknare:
Det är ett värde som hårdvara laddas .
En registrerad uppsättning:
Det är en samling av gemensamma register .
En stack:
Det är en rest av det specifik tråd .
Dessutom, om två trådar fungerar samtidigt i samma process, delar de koda , datasektioner , och andra operativsystemresurser som fil öppnas och signaler . En tungviktsprocess, en typ av konventionell process, kan styra en tråd. En multi-thread of control har dock kapacitet att öppna och utföra flera uppgifter samtidigt. Systemet blir avsevärt mer effektivt genom att använda trådar, varför de är användbara.
Skillnaden mellan enda och multitrådning i C förklaras. Först och främst är det en entrådig process . Som ett resultat, hela blocket, inklusive kod, data, etc.-betraktas som en process, och den processen har bara en tråd. Det betyder att denna teknik bara kommer att slutföra en uppgift i taget. Men det finns en flertrådsprocess som står i motsats till detta. Det finns aktiviteter som kod, stack, data , och filer likaså, men de utförs av flera trådar, som var och en har sin egen stack och register. Med tanke på att många uppgifter kan slutföras på en gång i denna situation kallas processen en flertrådsprocess .
Tråden finns i två varianter:
Tråd på användarnivå:
Det är på användarnivå, som namnet antyder. Kärnan ges inte åtkomst till dess data.
Tråd på kärnnivå
Typen av tråd hänvisar till trådens förhållande till kärnan och systemets operativsystem.
Bearbeta- Serien av steg som tas för att genomföra ett program kan kallas bearbeta . Ett program körs inte omedelbart när det körs. Det är uppdelat i några grundläggande steg som utförs sekventiellt på ett organiserat sätt för att så småningom leda till exekvering av en process.
En process som har brutits ner i mindre steg kallas en 'klon eller barnprocess', medan den ursprungliga processen kallas för 'föräldraprocess'. . I minnet använder varje process en viss mängd utrymme som inte delas med några andra processer.
En procedur går igenom några stadier före utförande.
NY-
I denna situation är en ny process genererad .
REDO-
När en process förbereds och väntar på att en processor ska tilldelas är den i detta tillstånd.
centos vs rhel
LÖPNING-
När processen är aktiv är det tillståndet.
VÄNTAR-
När en process är i detta tillstånd är det något väntar att hända.
AVSLUTAD-
Det är det tillstånd i vilket förfarandet genomförs.
Varför är C flertrådad?
Multithreading i C-idén kan utnyttjas genom parallellism för att förbättra en applikationens funktionalitet . Tänk på fallet där du har flera flikar öppna i ett webbläsarfönster. Sedan fungerar varje flik samtidigt och kan kallas en Tråd . Förutsatt att vi använder Microsoft excel , en tråd kommer att hantera textformatering , och en tråd kommer att göra det hantera inmatning . Därför gör C:s multithreading-funktion det enkelt att utföra flera uppgifter samtidigt. Skapandet av en tråd går betydligt snabbare. Kontextöverföringen över trådar sker snabbare. Dessutom kan kommunikation mellan trådar göras snabbare och trådavslutning är enkel.
Hur man skriver C-program för multithreading?
Även om flertrådsapplikationer inte är inbyggda i C-språket, är det möjligt beroende på operativsystem. De threads.h standardbibliotek används för att implementera multithreading-idén i C . Det finns dock för närvarande ingen kompilator som kan göra detta. Vi måste använda plattformsspecifika implementeringar, såsom 'POSIX' trådbibliotek, genom att använda rubrikfilen pthread.h , om vi vill använda multithreading i C. 'Pthreads' är ett annat namn för detta. A POSIX tråd kan skapas på följande sätt:
#include pthread_create (thread, attr, start_routine, arg)
I detta fall, Pthread_create skapar en ny tråd för att göra tråden körbar. Det låter dig implementera multithreading i C så många gånger du vill i din kod. Parametrarna och deras beskrivningar från tidigare listas här.
tråd:
Det är en singular identifikation Att den delprocess returnerar .
attr:
När vi vill ställa in trådattribut använder vi detta ogenomskinlig attribut .
android.process.acore stannar hela tiden
start_rutin:
När start_rutin genereras kommer tråden att köra en rutin.
arg:
Den parameter som start_rutin tar emot. NULL kommer att användas om inga argument ges.
Vissa C multithreading exempel
Här är några exempel på flertrådsproblem i C.
1. Läser-författare-frågan
Ett vanligt operativsystemproblem med processsynkronisering är läsare/skribentproblem . Anta att vi har en databas som Läsare och Författare , två olika användarkategorier, kan komma åt. Läsare är de enda som kan läsa databasen, medan Författare är de enda som kan läsa databasen och uppdatera den också. Låt oss använda IRCTC som ett enkelt exempel. Om vi vill kontrollera statusen för en specifik tågnummer , skriv helt enkelt in tågnumret i systemet för att se relevant tåginformation. Endast den information som finns på hemsidan visas här. Läsoperatorn är denna. Men om vi vill boka en biljett måste vi fylla i biljettbokningsformuläret med uppgifter som vårt namn, ålder och så vidare. Så vi utför en skrivoperation här. Det kommer att göras några justeringar IRCTC-databas .
Problemet är att flera personer samtidigt försöker komma åt IRCTC-databas . De kan vara en författare eller a läsare . Problemet uppstår om en läsare redan använder databasen och en skribent får åtkomst till den samtidigt för att arbeta med samma data. Ett annat problem uppstår när en författare använder en databas och en läsare får åtkomst till samma information som databasen. För det tredje finns det en svårighet när en författare uppdaterar databasen medan en annan försöker uppdatera data på samma databas. Det fjärde scenariot inträffar när två läsare försöker hämta samma material. Alla dessa problem uppstår om läsaren och skribenten använder samma databasdata.
Semafor är en metod som används för att lösa detta problem. Låt oss titta på en illustration av hur man använder det här problemet.
Läsprocess:
#include #include #include int rc = 0; // Reader count int data = 0; // Shared data pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_twrt = PTHREAD_COND_INITIALIZER; void* reader(void* arg) { int reader_id = *(int*)arg; pthread_mutex_lock(&mutex); rc++; if (rc == 1) pthread_cond_wait(&wrt, &mutex); pthread_mutex_unlock(&mutex); // Reading the shared data printf('Reader %d reads data: %d
', reader_id, data); pthread_mutex_lock(&mutex); rc--; if (rc == 0) pthread_cond_signal(&wrt); pthread_mutex_unlock(&mutex); return NULL; } int main() { pthread_treaders[5]; // Assuming 5 reader threads int reader_ids[5]; for (int i = 0; i<5; i++) { reader_ids[i]="i" + 1; pthread_create(&readers[i], null, reader, &reader_ids[i]); } joining reader threads for (int i="0;" i< 5; pthread_join(readers[i], null); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Reader 1 reads data: 0 Reader 2 reads data: 0 Reader 3 reads data: 0 Reader 4 reads data: 0 Reader 5 reads data: 0 </pre> <p> <strong>Explanation:</strong> </p> <p>In this code, we have the shared variable data and the <strong> <em>reader count rc</em> </strong> . The <strong> <em>wrt condition</em> </strong> variable is used to limit access for the <strong> <em>writer process</em> </strong> , and the <strong> <em>mutex</em> </strong> is used to guarantee mutual exclusion for accessing the shared data.</p> <p>The reader process is represented by the <strong> <em>reader() function</em> </strong> . The <strong> <em>reader count (rc)</em> </strong> is increased before attaining the <strong> <em>mutex lock</em> </strong> . It uses <strong> <em>pthread_cond_wait()</em> </strong> to wait on the <strong> <em>wrt condition</em> </strong> variable if it is the <strong> <em>first reader (rc == 1)</em> </strong> . As a result, writers will be prevented from writing until all readers have completed.</p> <p>The reader process checks if it was the <strong> <em>last reader (rc == 0)</em> </strong> and lowers the reader <strong> <em>count (rc--)</em> </strong> after reading the shared data. If it was, <strong> <em>pthread_cond_signal()</em> </strong> signals the <strong> <em>wrt condition</em> </strong> variable to let waiting writer processes continue.</p> <p>Using the <strong> <em>pthread_create()</em> </strong> and <strong> <em>pthread_join() functions</em> </strong> , we <strong> <em>new</em> </strong> and <strong> <em>join</em> </strong> multiple reader threads in the <strong> <em>main() function</em> </strong> . An individual ID is assigned to each reader thread for identifying purposes.</p> <h3>Writer process:</h3> <pre> wait(wrt); . . WRITE INTO THE OBJECT . signal(wrt); </pre> <p>In the above example, same as the <strong> <em>reader process</em> </strong> , an operation known as the wait operation is carried out on <strong> <em>'wrt'</em> </strong> when a user wishes to access the data or object. After that, the new user won't be able to access the object. And once the user has finished writing, another signal operation is performed on <strong> <em>wrt</em> </strong> .</p> <h3>2. lock and unlock problem:</h3> <p>The idea of a <strong> <em>mutex</em> </strong> is utilized in multithreading in C to guarantee that there won't be a <strong> <em>race condition</em> </strong> between the <strong> <em>threads</em> </strong> . When multiple threads begin processing the same data at once, this circumstance is known as <strong> <em>racing</em> </strong> . However, if these circumstances exist, we must. We use the <strong> <em>mutex's lock()</em> </strong> and <strong> <em>unlock() functions</em> </strong> to secure a particular section of code for a specific thread. Such that, another thread cannot begin performing the same operation. The <strong> <em>'critical section/region'</em> </strong> is the name given to this protected code area. Before using the shared resources, we set up a lot in a certain area, and once we've finished using them, we unlock them once more.</p> <p>Let's examine the operation of the mutex for locking and unlocking in multithreading in C:</p> <p> <strong>Example:</strong> </p> <pre> #include #include #include pthread_mutex_tmy_mutex = PTHREAD_MUTEX_INITIALIZER; int shared_data = 0; void *thread_function(void *arg) { pthread_mutex_lock(&my_mutex); shared_data++; // Modify the shared data printf('Thread %ld: Shared data modified. New value: %d
', (long)arg, shared_data); pthread_mutex_unlock(&my_mutex); return NULL; } int main() { pthread_tthreads[5]; // Assuming 5 threads for (int i = 0; i<5; i++) { if (pthread_create(&threads[i], null, thread_function, (void *)(long)(i + 1)) !="0)" fprintf(stderr, 'error creating thread %d
', i 1); return 1; } for (int i< 5; (pthread_join(threads[i], null) joining 0; < pre> <p> <strong>Output:</strong> </p> <pre> Thread 1: Shared data modified. New value: 1 Thread 2: Shared data modified. New value: 2 Thread 3: Shared data modified. New value: 3 Thread 4: Shared data modified. New value: 4 Thread 5: Shared data modified. New value: 5 </pre> <p> <strong>Explanation:</strong> </p> <p>In this above example, we explain how we <strong> <em>lock</em> </strong> and <strong> <em>unlock</em> </strong> a certain region of code that shields us from the racing situation. <strong> <em>'pthread_mutex_t'</em> </strong> is used as an <strong> <em>initializer</em> </strong> in the example above. <strong> <em>'pthread_mutex_lock'</em> </strong> is then <strong> <em>written</em> </strong> before the beginning of the code that we want to lock. The coding that we wish to lock is finished after that. After that, the locking of the code is terminated using <strong> <em>'pthread_mutex_unlock'</em> </strong> ; going forward, no code will be in lock mode.</p> <h2>The Dining Philosopher Problem:</h2> <p>One of the classic issues with synchronization is the <strong> <em>dining philosopher issue</em> </strong> . Simple resource allocation for several processes is required but shouldn't result in a <strong> <em>stalemate</em> </strong> or <strong> <em>hunger</em> </strong> . The <strong> <em>dining philosopher problem</em> </strong> can be viewed as a straightforward representation of a number of processes, each of which is demanding resources. Since each of these processes requires a resource allocation, it is necessary to distribute those resources across all of the processes so that no one process ever gets stuck or stops working.</p> <p>Assume there are five philosophers seated at a <strong> <em>circle-shaped table</em> </strong> . They eat at one point and ponder about something at another. Around the round table, the philosophers are evenly spaced out on the chairs. Additionally, there is a bowl of rice and five chopsticks for each philosopher in the middle of the table. When the philosopher feels she cannot interact with her colleagues who are seated nearby.</p> <p>A philosopher occasionally takes up two chopsticks when she becomes hungry. She chooses two chopsticks from her neighbors-one on her <strong> <em>left</em> </strong> and one on her <strong> <em>right</em> </strong> -that are within easy reach. But the philosopher should never pick up more than one chopstick at once. She will obviously be unable to pick up the chopstick that the neighbor is using.</p> <p> <strong>Example:</strong> </p> <p>Let's use an example to demonstrate how this is implemented in C.</p> <pre> #include #include #include #include #include pthread_tphilosopher[5]; pthread_mutex_tchopstick[5]; void *func(void *arg) { int n = *(int *)arg; printf('
Philosopher %d is thinking.', n); pthread_mutex_lock(&chopstick[n]); pthread_mutex_lock(&chopstick[(n + 1) % 5]); printf('
Philosopher %d is eating.', n); sleep(3); pthread_mutex_unlock(&chopstick[n]); pthread_mutex_unlock(&chopstick[(n + 1) % 5]); printf('
Philosopher %d Finished eating ', n); return NULL; } int main() { int i, k; void *message; for (i = 0; i<5; i++) { k="pthread_mutex_init(&chopstick[i]," null); if (k !="0)" printf('failed to initialize the mutex
'); exit(1); } for (i="0;" i< 5; null, func, (void *)&i); printf('error in thread creation.
'); &message); join thread.
'); printf('mutex destroyed.
'); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Philosopher 0 is thinking. Philosopher 1 is thinking. Philosopher 2 is thinking. Philosopher 3 is thinking. Philosopher 4 is thinking. Philosopher 0 is eating. Philosopher 1 is eating. Philosopher 2 is eating. Philosopher 3 is eating. Philosopher 4 is eating. Philosopher 0 Finished eating Philosopher 1 Finished eating Philosopher 2 Finished eating Philosopher 3 Finished eating Philosopher 4 Finished eating </pre> <p> <strong>Explanation:</strong> </p> <p> <strong> <em>Chopsticks</em> </strong> can be represented by a semaphore. Since there are <strong> <em>chopsticks</em> </strong> on the table and no philosopher has chosen one, all of the chopsticks' components are first initialized to <strong> <em>1</em> </strong> . Now that <strong> <em>chopstick[i]</em> </strong> has been chosen as the first <strong> <em>chopstick. chopstick[i]</em> </strong> and <strong> <em>chopstick[(i+1)%5]</em> </strong> are subject to the first wait operation. These <strong> <em>chopsticks' wait operation</em> </strong> indicates that the philosopher has picked them up. The eating process begins once the philosopher selects his <strong> <em>chopstick</em> </strong> . The signal operation is now carried out on the <strong> <em>chopsticks [i]</em> </strong> and <strong> <em>[(i+1)%5]</em> </strong> once the philosopher has finished eating. The philosopher then turns back to sleep.</p> <p>To determine whether the <strong> <em>subthread</em> </strong> has joined the main thread or not, we used the <strong> <em>pthread_join function</em> </strong> . Similarly, we have checked whether the <strong> <em>mutex</em> </strong> lock has been initialized using the <strong> <em>pthread_mutex_init</em> </strong> method.</p> <p>To initialize and verify whether the new thread was created or not, we utilized the <strong> <em>pthread_create function</em> </strong> . Similar to this, we destroyed the <strong> <em>mutex lock</em> </strong> using the <strong> <em>pthread_mutex_destroy</em> </strong> function.</p> <h2>The Producer-Consumer Problem:</h2> <p>A common issue with multithreading process synchronization is the <strong> <em>producer-consumer problem</em> </strong> . Two processes are present in it: the first is the <strong> <em>producer's process</em> </strong> , and the second is the <strong> <em>consumer's process</em> </strong> . Furthermore, it is assumed that both operations are occurring concurrently in parallel. Additionally, they are a cooperative process, which implies that they are sharing something with one another. It is important that when the buffer is <strong> <em>full</em> </strong> , the producer cannot add data. When the buffer is empty, the consumer cannot extract data from the buffer because the common buffer size between the producer and the consumer is <strong> <em>fixed</em> </strong> . The issue is stated in this way. Hence, to implement the Producer-Consumer problem and solve it, we shall employ the idea of parallel programming.</p> <p> <strong>Example:</strong> </p> <pre> #include #include int mutex = 1, full = 0, empty = 3, x = 0; int main() { int n; void producer(); void consumer(); int wait(int); int signal(int); printf('
1.producer
2.consumer
3.for exit'); while (1) { printf('
Please enter your choice:'); scanf('%d', &n); switch (n) { case 1: if ((mutex == 1) && (empty != 0)) producer(); else printf('Oops!! the buffer is full!!'); break; case 2: if ((mutex == 1) && (full != 0)) consumer(); else printf('Oops!! the buffer is empty!!'); break; case 3: exit(0); break; } } return 0; } int wait(int s) { return (--s); } int signal(int s) { return (++s); } void producer() { mutex = wait(mutex); full = signal(full); empty = wait(empty); x++; printf('
Item produced by the Producer %d', x); mutex = signal(mutex); } void consumer() { mutex = wait(mutex); full = wait(full); empty = signal(empty); printf('
Item consumed by the Consumer %d', x); x--; mutex = signal(mutex); } </pre> <p> <strong>Output:</strong> </p> <pre> 1. producer 2. consumer 3. for exit Please enter your choice: </pre> <p> <strong>Explanation:</strong> </p> <p>We perform two tasks. The functions <strong> <em>consumer()</em> </strong> and <strong> <em>producer()</em> </strong> indicate the status and operation of the <strong> <em>consumer</em> </strong> and <strong> <em>producer</em> </strong> . The <strong> <em>producer() method</em> </strong> will create the <strong> <em>mutex lock</em> </strong> and determine whether the buffer is <strong> <em>full</em> </strong> when it is called. When the buffer is full, nothing will be produced. If not, it will <strong> <em>create</em> </strong> , and then, after the <strong> <em>production</em> </strong> , it will put itself to sleep to unlock the <strong> <em>mutex lock</em> </strong> . Like the <strong> <em>producer</em> </strong> , the consumer first creates the <strong> <em>mutex lock</em> </strong> , checks the <strong> <em>buffer</em> </strong> , consumes the <strong> <em>product</em> </strong> , and then releases the lock before going back to sleep.</p> <p>A <strong> <em>counter (x)</em> </strong> will be used during manufacturing and will keep growing until the manufacturer produces the item. However, the consumer will make fewer of the same manufactured <strong> <em>item (x)</em> </strong> .</p> <h2>Conclusion:</h2> <p>The idea of using <strong> <em>two</em> </strong> or <strong> <em>more threads</em> </strong> to execute a program is known as <strong> <em>multithreading</em> </strong> in the C programming language. <strong> <em>Multithreading</em> </strong> allows for the simultaneous execution of several tasks. The simplest executable component of a program is a <strong> <em>thread</em> </strong> . The process is the idea that a task can be completed by breaking it up into several smaller <strong> <em>sub-processes</em> </strong> .</p> <p>The header file <strong> <em>pthread.h</em> </strong> is required in order to implement multithreading in C since it cannot be done directly.</p> <hr></5;></pre></5;></pre></5;> Förklaring:
I den här koden har vi delade variabeldata och läsarräkning rc . De wrt skick variabel används för att begränsa åtkomsten för författarprocess , och den mutex används för att garantera ömsesidig uteslutning för åtkomst till delade data.
Läsarprocessen representeras av reader() funktion . De antal läsare (rc) ökas innan man uppnår mutex lås . Det använder pthread_cond_wait() att vänta på wrt skick variabel om det är första läsaren (rc == 1) . Som ett resultat kommer skribenter att hindras från att skriva tills alla läsare har slutfört.
Läsarprocessen kontrollerar om det var sista läsaren (rc == 0) och sänker läsaren räkna (rc--) efter att ha läst de delade uppgifterna. Om det var, pthread_cond_signal() signalerar wrt skick variabel för att låta väntande skribentprocesser fortsätta.
Använda pthread_create() och pthread_join() funktioner , vi ny och Ansluta sig flera läsartrådar i huvudfunktion . Ett individuellt ID tilldelas varje läsartråd i identifieringssyfte.
Författarprocess:
wait(wrt); . . WRITE INTO THE OBJECT . signal(wrt);
I exemplet ovan, samma som läsarprocess , en operation känd som vänteoperationen utförs på 'wrt' när en användare vill komma åt data eller objekt. Efter det kommer den nya användaren inte att kunna komma åt objektet. Och när användaren har skrivit klart, utförs ytterligare en signaloperation på wrt .
2. problem med låsning och upplåsning:
Idén med en mutex används i multithreading i C för att garantera att det inte finns en loppets skick mellan trådar . När flera trådar börjar behandla samma data på en gång kallas denna omständighet tävlings . Men om dessa omständigheter finns måste vi. Vi använder mutex's lock() och unlock() funktioner för att säkra ett visst avsnitt av kod för en specifik tråd. Så att en annan tråd inte kan börja utföra samma operation. De 'kritisk sektion/region' är namnet på detta skyddade kodområde. Innan vi använder de delade resurserna ställer vi upp mycket inom ett visst område, och när vi har använt dem färdigt låser vi upp dem en gång till.
Låt oss undersöka funktionen för mutex för låsning och upplåsning i multithreading i C:
Exempel:
#include #include #include pthread_mutex_tmy_mutex = PTHREAD_MUTEX_INITIALIZER; int shared_data = 0; void *thread_function(void *arg) { pthread_mutex_lock(&my_mutex); shared_data++; // Modify the shared data printf('Thread %ld: Shared data modified. New value: %d
', (long)arg, shared_data); pthread_mutex_unlock(&my_mutex); return NULL; } int main() { pthread_tthreads[5]; // Assuming 5 threads for (int i = 0; i<5; i++) { if (pthread_create(&threads[i], null, thread_function, (void *)(long)(i + 1)) !="0)" fprintf(stderr, \'error creating thread %d
\', i 1); return 1; } for (int i< 5; (pthread_join(threads[i], null) joining 0; < pre> <p> <strong>Output:</strong> </p> <pre> Thread 1: Shared data modified. New value: 1 Thread 2: Shared data modified. New value: 2 Thread 3: Shared data modified. New value: 3 Thread 4: Shared data modified. New value: 4 Thread 5: Shared data modified. New value: 5 </pre> <p> <strong>Explanation:</strong> </p> <p>In this above example, we explain how we <strong> <em>lock</em> </strong> and <strong> <em>unlock</em> </strong> a certain region of code that shields us from the racing situation. <strong> <em>'pthread_mutex_t'</em> </strong> is used as an <strong> <em>initializer</em> </strong> in the example above. <strong> <em>'pthread_mutex_lock'</em> </strong> is then <strong> <em>written</em> </strong> before the beginning of the code that we want to lock. The coding that we wish to lock is finished after that. After that, the locking of the code is terminated using <strong> <em>'pthread_mutex_unlock'</em> </strong> ; going forward, no code will be in lock mode.</p> <h2>The Dining Philosopher Problem:</h2> <p>One of the classic issues with synchronization is the <strong> <em>dining philosopher issue</em> </strong> . Simple resource allocation for several processes is required but shouldn't result in a <strong> <em>stalemate</em> </strong> or <strong> <em>hunger</em> </strong> . The <strong> <em>dining philosopher problem</em> </strong> can be viewed as a straightforward representation of a number of processes, each of which is demanding resources. Since each of these processes requires a resource allocation, it is necessary to distribute those resources across all of the processes so that no one process ever gets stuck or stops working.</p> <p>Assume there are five philosophers seated at a <strong> <em>circle-shaped table</em> </strong> . They eat at one point and ponder about something at another. Around the round table, the philosophers are evenly spaced out on the chairs. Additionally, there is a bowl of rice and five chopsticks for each philosopher in the middle of the table. When the philosopher feels she cannot interact with her colleagues who are seated nearby.</p> <p>A philosopher occasionally takes up two chopsticks when she becomes hungry. She chooses two chopsticks from her neighbors-one on her <strong> <em>left</em> </strong> and one on her <strong> <em>right</em> </strong> -that are within easy reach. But the philosopher should never pick up more than one chopstick at once. She will obviously be unable to pick up the chopstick that the neighbor is using.</p> <p> <strong>Example:</strong> </p> <p>Let's use an example to demonstrate how this is implemented in C.</p> <pre> #include #include #include #include #include pthread_tphilosopher[5]; pthread_mutex_tchopstick[5]; void *func(void *arg) { int n = *(int *)arg; printf('
Philosopher %d is thinking.', n); pthread_mutex_lock(&chopstick[n]); pthread_mutex_lock(&chopstick[(n + 1) % 5]); printf('
Philosopher %d is eating.', n); sleep(3); pthread_mutex_unlock(&chopstick[n]); pthread_mutex_unlock(&chopstick[(n + 1) % 5]); printf('
Philosopher %d Finished eating ', n); return NULL; } int main() { int i, k; void *message; for (i = 0; i<5; i++) { k="pthread_mutex_init(&chopstick[i]," null); if (k !="0)" printf(\'failed to initialize the mutex
\'); exit(1); } for (i="0;" i< 5; null, func, (void *)&i); printf(\'error in thread creation.
\'); &message); join thread.
\'); printf(\'mutex destroyed.
\'); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Philosopher 0 is thinking. Philosopher 1 is thinking. Philosopher 2 is thinking. Philosopher 3 is thinking. Philosopher 4 is thinking. Philosopher 0 is eating. Philosopher 1 is eating. Philosopher 2 is eating. Philosopher 3 is eating. Philosopher 4 is eating. Philosopher 0 Finished eating Philosopher 1 Finished eating Philosopher 2 Finished eating Philosopher 3 Finished eating Philosopher 4 Finished eating </pre> <p> <strong>Explanation:</strong> </p> <p> <strong> <em>Chopsticks</em> </strong> can be represented by a semaphore. Since there are <strong> <em>chopsticks</em> </strong> on the table and no philosopher has chosen one, all of the chopsticks' components are first initialized to <strong> <em>1</em> </strong> . Now that <strong> <em>chopstick[i]</em> </strong> has been chosen as the first <strong> <em>chopstick. chopstick[i]</em> </strong> and <strong> <em>chopstick[(i+1)%5]</em> </strong> are subject to the first wait operation. These <strong> <em>chopsticks' wait operation</em> </strong> indicates that the philosopher has picked them up. The eating process begins once the philosopher selects his <strong> <em>chopstick</em> </strong> . The signal operation is now carried out on the <strong> <em>chopsticks [i]</em> </strong> and <strong> <em>[(i+1)%5]</em> </strong> once the philosopher has finished eating. The philosopher then turns back to sleep.</p> <p>To determine whether the <strong> <em>subthread</em> </strong> has joined the main thread or not, we used the <strong> <em>pthread_join function</em> </strong> . Similarly, we have checked whether the <strong> <em>mutex</em> </strong> lock has been initialized using the <strong> <em>pthread_mutex_init</em> </strong> method.</p> <p>To initialize and verify whether the new thread was created or not, we utilized the <strong> <em>pthread_create function</em> </strong> . Similar to this, we destroyed the <strong> <em>mutex lock</em> </strong> using the <strong> <em>pthread_mutex_destroy</em> </strong> function.</p> <h2>The Producer-Consumer Problem:</h2> <p>A common issue with multithreading process synchronization is the <strong> <em>producer-consumer problem</em> </strong> . Two processes are present in it: the first is the <strong> <em>producer's process</em> </strong> , and the second is the <strong> <em>consumer's process</em> </strong> . Furthermore, it is assumed that both operations are occurring concurrently in parallel. Additionally, they are a cooperative process, which implies that they are sharing something with one another. It is important that when the buffer is <strong> <em>full</em> </strong> , the producer cannot add data. When the buffer is empty, the consumer cannot extract data from the buffer because the common buffer size between the producer and the consumer is <strong> <em>fixed</em> </strong> . The issue is stated in this way. Hence, to implement the Producer-Consumer problem and solve it, we shall employ the idea of parallel programming.</p> <p> <strong>Example:</strong> </p> <pre> #include #include int mutex = 1, full = 0, empty = 3, x = 0; int main() { int n; void producer(); void consumer(); int wait(int); int signal(int); printf('
1.producer
2.consumer
3.for exit'); while (1) { printf('
Please enter your choice:'); scanf('%d', &n); switch (n) { case 1: if ((mutex == 1) && (empty != 0)) producer(); else printf('Oops!! the buffer is full!!'); break; case 2: if ((mutex == 1) && (full != 0)) consumer(); else printf('Oops!! the buffer is empty!!'); break; case 3: exit(0); break; } } return 0; } int wait(int s) { return (--s); } int signal(int s) { return (++s); } void producer() { mutex = wait(mutex); full = signal(full); empty = wait(empty); x++; printf('
Item produced by the Producer %d', x); mutex = signal(mutex); } void consumer() { mutex = wait(mutex); full = wait(full); empty = signal(empty); printf('
Item consumed by the Consumer %d', x); x--; mutex = signal(mutex); } </pre> <p> <strong>Output:</strong> </p> <pre> 1. producer 2. consumer 3. for exit Please enter your choice: </pre> <p> <strong>Explanation:</strong> </p> <p>We perform two tasks. The functions <strong> <em>consumer()</em> </strong> and <strong> <em>producer()</em> </strong> indicate the status and operation of the <strong> <em>consumer</em> </strong> and <strong> <em>producer</em> </strong> . The <strong> <em>producer() method</em> </strong> will create the <strong> <em>mutex lock</em> </strong> and determine whether the buffer is <strong> <em>full</em> </strong> when it is called. When the buffer is full, nothing will be produced. If not, it will <strong> <em>create</em> </strong> , and then, after the <strong> <em>production</em> </strong> , it will put itself to sleep to unlock the <strong> <em>mutex lock</em> </strong> . Like the <strong> <em>producer</em> </strong> , the consumer first creates the <strong> <em>mutex lock</em> </strong> , checks the <strong> <em>buffer</em> </strong> , consumes the <strong> <em>product</em> </strong> , and then releases the lock before going back to sleep.</p> <p>A <strong> <em>counter (x)</em> </strong> will be used during manufacturing and will keep growing until the manufacturer produces the item. However, the consumer will make fewer of the same manufactured <strong> <em>item (x)</em> </strong> .</p> <h2>Conclusion:</h2> <p>The idea of using <strong> <em>two</em> </strong> or <strong> <em>more threads</em> </strong> to execute a program is known as <strong> <em>multithreading</em> </strong> in the C programming language. <strong> <em>Multithreading</em> </strong> allows for the simultaneous execution of several tasks. The simplest executable component of a program is a <strong> <em>thread</em> </strong> . The process is the idea that a task can be completed by breaking it up into several smaller <strong> <em>sub-processes</em> </strong> .</p> <p>The header file <strong> <em>pthread.h</em> </strong> is required in order to implement multithreading in C since it cannot be done directly.</p> <hr></5;></pre></5;> Förklaring:
jframe
I det här exemplet ovan förklarar vi hur vi låsa och låsa upp en viss kodregion som skyddar oss från racingsituationen. 'pthread_mutex_t' används som en initialiserare i exemplet ovan. 'pthread_mutex_lock' är då skriven före början av koden som vi vill låsa. Kodningen som vi vill låsa är klar efter det. Därefter avslutas låsningen av koden med 'pthread_mutex_unlock' ; Framöver kommer ingen kod att vara i låst läge.
Matfilosofproblemet:
En av de klassiska problemen med synkronisering är middagsfilosoffråga . Enkel resursallokering för flera processer krävs men bör inte resultera i en dödläge eller hunger . De middagsfilosofproblem kan ses som en enkel representation av ett antal processer, som var och en kräver resurser. Eftersom var och en av dessa processer kräver en resursallokering är det nödvändigt att fördela dessa resurser över alla processer så att ingen process någonsin fastnar eller slutar fungera.
Antag att det finns fem filosofer som sitter vid en cirkelformat bord . De äter vid ett tillfälle och funderar över något vid ett annat. Runt det runda bordet står filosoferna jämnt fördelade på stolarna. Dessutom finns det en skål med ris och fem ätpinnar för varje filosof i mitten av bordet. När filosofen känner att hon inte kan interagera med sina kollegor som sitter i närheten.
En filosof tar då och då upp två ätpinnar när hon blir hungrig. Hon väljer två ätpinnar från sina grannar - en på henne vänster och en på henne höger -som är inom räckhåll. Men filosofen bör aldrig plocka upp mer än en ätpinne på en gång. Hon kommer uppenbarligen inte att kunna ta upp ätpinnen som grannen använder.
Exempel:
konvertera en sträng till heltal i java
Låt oss använda ett exempel för att visa hur detta implementeras i C.
#include #include #include #include #include pthread_tphilosopher[5]; pthread_mutex_tchopstick[5]; void *func(void *arg) { int n = *(int *)arg; printf('
Philosopher %d is thinking.', n); pthread_mutex_lock(&chopstick[n]); pthread_mutex_lock(&chopstick[(n + 1) % 5]); printf('
Philosopher %d is eating.', n); sleep(3); pthread_mutex_unlock(&chopstick[n]); pthread_mutex_unlock(&chopstick[(n + 1) % 5]); printf('
Philosopher %d Finished eating ', n); return NULL; } int main() { int i, k; void *message; for (i = 0; i<5; i++) { k="pthread_mutex_init(&chopstick[i]," null); if (k !="0)" printf(\'failed to initialize the mutex
\'); exit(1); } for (i="0;" i< 5; null, func, (void *)&i); printf(\'error in thread creation.
\'); &message); join thread.
\'); printf(\'mutex destroyed.
\'); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Philosopher 0 is thinking. Philosopher 1 is thinking. Philosopher 2 is thinking. Philosopher 3 is thinking. Philosopher 4 is thinking. Philosopher 0 is eating. Philosopher 1 is eating. Philosopher 2 is eating. Philosopher 3 is eating. Philosopher 4 is eating. Philosopher 0 Finished eating Philosopher 1 Finished eating Philosopher 2 Finished eating Philosopher 3 Finished eating Philosopher 4 Finished eating </pre> <p> <strong>Explanation:</strong> </p> <p> <strong> <em>Chopsticks</em> </strong> can be represented by a semaphore. Since there are <strong> <em>chopsticks</em> </strong> on the table and no philosopher has chosen one, all of the chopsticks' components are first initialized to <strong> <em>1</em> </strong> . Now that <strong> <em>chopstick[i]</em> </strong> has been chosen as the first <strong> <em>chopstick. chopstick[i]</em> </strong> and <strong> <em>chopstick[(i+1)%5]</em> </strong> are subject to the first wait operation. These <strong> <em>chopsticks' wait operation</em> </strong> indicates that the philosopher has picked them up. The eating process begins once the philosopher selects his <strong> <em>chopstick</em> </strong> . The signal operation is now carried out on the <strong> <em>chopsticks [i]</em> </strong> and <strong> <em>[(i+1)%5]</em> </strong> once the philosopher has finished eating. The philosopher then turns back to sleep.</p> <p>To determine whether the <strong> <em>subthread</em> </strong> has joined the main thread or not, we used the <strong> <em>pthread_join function</em> </strong> . Similarly, we have checked whether the <strong> <em>mutex</em> </strong> lock has been initialized using the <strong> <em>pthread_mutex_init</em> </strong> method.</p> <p>To initialize and verify whether the new thread was created or not, we utilized the <strong> <em>pthread_create function</em> </strong> . Similar to this, we destroyed the <strong> <em>mutex lock</em> </strong> using the <strong> <em>pthread_mutex_destroy</em> </strong> function.</p> <h2>The Producer-Consumer Problem:</h2> <p>A common issue with multithreading process synchronization is the <strong> <em>producer-consumer problem</em> </strong> . Two processes are present in it: the first is the <strong> <em>producer's process</em> </strong> , and the second is the <strong> <em>consumer's process</em> </strong> . Furthermore, it is assumed that both operations are occurring concurrently in parallel. Additionally, they are a cooperative process, which implies that they are sharing something with one another. It is important that when the buffer is <strong> <em>full</em> </strong> , the producer cannot add data. When the buffer is empty, the consumer cannot extract data from the buffer because the common buffer size between the producer and the consumer is <strong> <em>fixed</em> </strong> . The issue is stated in this way. Hence, to implement the Producer-Consumer problem and solve it, we shall employ the idea of parallel programming.</p> <p> <strong>Example:</strong> </p> <pre> #include #include int mutex = 1, full = 0, empty = 3, x = 0; int main() { int n; void producer(); void consumer(); int wait(int); int signal(int); printf('
1.producer
2.consumer
3.for exit'); while (1) { printf('
Please enter your choice:'); scanf('%d', &n); switch (n) { case 1: if ((mutex == 1) && (empty != 0)) producer(); else printf('Oops!! the buffer is full!!'); break; case 2: if ((mutex == 1) && (full != 0)) consumer(); else printf('Oops!! the buffer is empty!!'); break; case 3: exit(0); break; } } return 0; } int wait(int s) { return (--s); } int signal(int s) { return (++s); } void producer() { mutex = wait(mutex); full = signal(full); empty = wait(empty); x++; printf('
Item produced by the Producer %d', x); mutex = signal(mutex); } void consumer() { mutex = wait(mutex); full = wait(full); empty = signal(empty); printf('
Item consumed by the Consumer %d', x); x--; mutex = signal(mutex); } </pre> <p> <strong>Output:</strong> </p> <pre> 1. producer 2. consumer 3. for exit Please enter your choice: </pre> <p> <strong>Explanation:</strong> </p> <p>We perform two tasks. The functions <strong> <em>consumer()</em> </strong> and <strong> <em>producer()</em> </strong> indicate the status and operation of the <strong> <em>consumer</em> </strong> and <strong> <em>producer</em> </strong> . The <strong> <em>producer() method</em> </strong> will create the <strong> <em>mutex lock</em> </strong> and determine whether the buffer is <strong> <em>full</em> </strong> when it is called. When the buffer is full, nothing will be produced. If not, it will <strong> <em>create</em> </strong> , and then, after the <strong> <em>production</em> </strong> , it will put itself to sleep to unlock the <strong> <em>mutex lock</em> </strong> . Like the <strong> <em>producer</em> </strong> , the consumer first creates the <strong> <em>mutex lock</em> </strong> , checks the <strong> <em>buffer</em> </strong> , consumes the <strong> <em>product</em> </strong> , and then releases the lock before going back to sleep.</p> <p>A <strong> <em>counter (x)</em> </strong> will be used during manufacturing and will keep growing until the manufacturer produces the item. However, the consumer will make fewer of the same manufactured <strong> <em>item (x)</em> </strong> .</p> <h2>Conclusion:</h2> <p>The idea of using <strong> <em>two</em> </strong> or <strong> <em>more threads</em> </strong> to execute a program is known as <strong> <em>multithreading</em> </strong> in the C programming language. <strong> <em>Multithreading</em> </strong> allows for the simultaneous execution of several tasks. The simplest executable component of a program is a <strong> <em>thread</em> </strong> . The process is the idea that a task can be completed by breaking it up into several smaller <strong> <em>sub-processes</em> </strong> .</p> <p>The header file <strong> <em>pthread.h</em> </strong> is required in order to implement multithreading in C since it cannot be done directly.</p> <hr></5;> Förklaring:
Ätpinnar kan representeras av en semafor. Eftersom det finns ätpinnar på bordet och ingen filosof har valt en, initieras först alla ätpinnars komponenter till 1 . Nu när ätpinne[i] har valts ut som den första matpinne. ätpinne[i] och ätpinne[(i+1)%5] är föremål för den första vänteoperationen. Dessa ätpinnars vänteoperation indikerar att filosofen har plockat upp dem. Ätprocessen börjar när filosofen väljer sitt matpinne . Signaloperationen utförs nu på ätpinnar [i] och [(i+1)%5] när filosofen har ätit färdigt. Filosofen somnar sedan om igen.
För att avgöra om undertråd har gått med i huvudtråden eller inte, vi använde den pthread_join-funktionen . På samma sätt har vi kontrollerat om mutex låset har initierats med hjälp av pthread_mutex_init metod.
För att initiera och verifiera om den nya tråden skapades eller inte, använde vi pthread_create-funktionen . I likhet med detta förstörde vi mutex lås använda pthread_mutex_destroy fungera.
Producent-konsumentproblemet:
Ett vanligt problem med flertrådsprocesssynkronisering är producent-konsument problem . Två processer är närvarande i den: den första är producentens process , och den andra är konsumentens process . Vidare antas att båda operationerna sker samtidigt parallellt. Dessutom är de en samarbetsprocess, vilket innebär att de delar något med varandra. Det är viktigt att när bufferten är full , kan producenten inte lägga till data. När bufferten är tom kan konsumenten inte extrahera data från bufferten eftersom den gemensamma buffertstorleken mellan producent och konsument är det fast . Frågan uttrycks på detta sätt. För att implementera producent-konsumentproblemet och lösa det kommer vi därför att använda idén om parallell programmering.
Exempel:
#include #include int mutex = 1, full = 0, empty = 3, x = 0; int main() { int n; void producer(); void consumer(); int wait(int); int signal(int); printf('
1.producer
2.consumer
3.for exit'); while (1) { printf('
Please enter your choice:'); scanf('%d', &n); switch (n) { case 1: if ((mutex == 1) && (empty != 0)) producer(); else printf('Oops!! the buffer is full!!'); break; case 2: if ((mutex == 1) && (full != 0)) consumer(); else printf('Oops!! the buffer is empty!!'); break; case 3: exit(0); break; } } return 0; } int wait(int s) { return (--s); } int signal(int s) { return (++s); } void producer() { mutex = wait(mutex); full = signal(full); empty = wait(empty); x++; printf('
Item produced by the Producer %d', x); mutex = signal(mutex); } void consumer() { mutex = wait(mutex); full = wait(full); empty = signal(empty); printf('
Item consumed by the Consumer %d', x); x--; mutex = signal(mutex); } Produktion:
1. producer 2. consumer 3. for exit Please enter your choice:
Förklaring:
Vi utför två uppgifter. Funktionerna konsument() och producent() ange status och funktion för konsument och producent . De producer() metod kommer att skapa mutex lås och avgöra om bufferten är full när det kallas. När bufferten är full kommer ingenting att produceras. Om inte, kommer det att göra det skapa , och sedan, efter produktion , kommer den att försätta sig själv för att låsa upp mutex lås . Som producent , skapar konsumenten först mutex lås , kontrollerar buffert , förbrukar produkt , och släpper sedan låset innan du går i viloläge igen.
A räknare (x) kommer att användas under tillverkningen och kommer att fortsätta växa tills tillverkaren producerar varan. Däremot kommer konsumenten att göra färre av samma tillverkade objekt (x) .
Slutsats:
Tanken på att använda två eller fler trådar att köra ett program kallas multitrådning i programmeringsspråket C. Multithreading gör det möjligt att utföra flera uppgifter samtidigt. Den enklaste körbara komponenten i ett program är en tråd . Processen är tanken att en uppgift kan slutföras genom att dela upp den i flera mindre delprocesser .
Rubrikfilen pthread.h krävs för att implementera multithreading i C eftersom det inte kan göras direkt.