Увод:
У Ц, термин 'вишенитност' описује употребу бројних нити истовремено. Свака нит ради а другачији задатак . Због истовремене природе вишенитног рада, многи задаци се могу обављати одједном. Поред тога, мултитхреадинг смањује Коришћење ресурса ЦПУ-а . Постоје две категорије мултитаскинга: заснован на процесу и засновано на нитима . Када се било шта опише као вишенитност, то значи да се најмање две или можда више нити покрећу у истом процесу одједном. Прво морамо да разумемо шта су нит и процес да бисмо разумели вишенитност у Ц. Хајде да погледамо ове теме да бисмо боље разумели.
Име
Шта су процеси и нити?
А конац је фундаментална зграда блокирати извршења било ког процеса. Програм се састоји од неколико процеса, а сваки процес се састоји од нити, које су много основне јединице. Према томе, нит се може сматрати основним градивним блоком процеса или једноставнијом јединицом која заједнички одређује коришћење ЦПУ-а.
Следеће ставке су укључене у нит:
ИД нити:
То је посебна ИД нити који се генерише у време формирања нити и задржава се за време трајања те специфичне нити.
Програмски бројач:
То је вредност коју хардверска оптерећења .
Регистровани сет:
То је збирка од заједнички регистри .
Стог:
То је остатак тога специфична нит .
Поред тога, ако две нити раде истовремено у истом процесу, оне деле код , секције података , и други ресурси оперативног система попут датотеке отвара и сигнали . Тешки процес, тип конвенционалног процеса, може контролисати једну нит. Међутим, контрола са више нити има капацитет да отвори и изврши више задатака истовремено. Систем постаје знатно ефикаснији као резултат коришћења нити, због чега су корисни.
Разлика између једно и мултитхреадинг у Ц је објашњено. Пре свега, то је а једнонитни процес . Као резултат, цео блок, укључујући код, подаци, итд.- сматра се једним процесом, а тај процес има само једну нит. То значи да ће ова техника обављати само један по један задатак. Али постоји а вишенитни процес то стоји у супротности са овим. Постоје активности као код, стек, подаци , и фајлови такође, али их изводи неколико нити, од којих свака има свој стек и регистре. С обзиром на то да се у овој ситуацији могу одједном извршити бројни задаци, процес је познат као а вишенитни процес .
Конац долази у две варијанте:
Нит на нивоу корисника:
То је на нивоу корисника, као што име говори. Кернелу није дат приступ својим подацима.
Нит на нивоу кернела
Врста нити се односи на однос нити према језгру и оперативном систему система.
Процес- Низ корака предузетих за извођење програма може се назвати процес . Програм се не извршава одмах када се покрене. Подијељен је на неколико основних корака који се спроводе узастопно на организован начин како би на крају довели до извршења процеса.
Процес који је подељен на мање кораке се назива а 'клон или дете процес', док се оригинални процес назива 'родитељски' процес . У меморији, сваки процес користи одређену количину простора који се не дели ни са једним другим процесом.
Процедура пролази кроз неколико фаза пре извршења.
НОВА-
У овој ситуацији, нови процес је генерисан .
СПРЕМНИ-
Када је процес припремљен и чека да му се додели процесор, он је у овом стању.
ТРЧАЊЕ-
Када је процес активан, то је држава.
на стринг метод јава
ЧЕКА-
Када је процес у овом стању, нешто јесте чекајући десити се.
РАСКИНУТ-
То је држава у којој се поступак спроводи.
Зашто је Ц вишенит?
Мултитхреадинг у Ц идеја се може искористити кроз паралелизам за побољшање ан функционалност апликације . Размотрите случај када имате неколико картица отворених у прозору прегледача. Затим, свака картица ради истовремено и може се назвати а Тхреад . Под претпоставком да користимо Мицрософт Екцел , једна нит ће се снаћи форматирање текста , а једна нит ће руковати уносом . Стога, Ц-ова функција вишенитног рада олакшава обављање више задатака одједном. Стварање нити је знатно брже. Пренос контекста преко нити се дешава брже. Поред тога, комуникација између нити може бити бржа, а завршетак нити је једноставан.
Како написати Ц програме за вишенитност?
Иако апликације са више нити нису уграђене у језик Ц, то је могуће у зависности од оперативног система. Тхе тхреадс.х стандардна библиотека се користи за имплементацију идеје вишенитног у Ц . Међутим, тренутно не постоји компајлер који то може да уради. Морамо користити имплементације специфичне за платформу, као што је 'ПОСИКС' библиотеку нити, користећи датотеку заглавља птхреад.х , ако желимо да користимо вишенитност у Ц. 'Птхреадс' је друго име за ово. А ПОСИКС нит се може креирати на следеће начине:
#include pthread_create (thread, attr, start_routine, arg)
У овом случају, Птхреад_цреате креира нову нит како би нит била извршна. Омогућава вам да имплементирате вишенитно у Ц колико год пута желите у свом коду. Овде су наведени параметри и њихови описи од раније.
нит:
То је сингуларна идентификација да је подпроцес враћа .
аттр:
Када желимо да поставимо атрибуте нити, користимо ово непрозиран атрибут .
старт_роутине:
Када старт_роутине се генерише, нит ће покренути рутину.
арг:
Параметар који је старт_роутине прима. НУЛА ће се користити ако нису дати аргументи.
лисица или вук
Одређени примери вишенитног Ц
Ево неколико примера проблема са више нити у Ц.
1. Питање читаоца и писца
Уобичајени проблем са оперативним системом са синхронизацијом процеса је проблем читаоца/писца . Претпоставимо да имамо базу података која Реадерс и Писци , могу приступити две различите категорије корисника. Реадерс су једини који могу читати база података, док Писци су једини који могу да читају базу података и да је ажурирају. Хајде да користимо ИРЦТЦ као једноставан пример. Ако желимо да проверимо статус одређеног број воза , једноставно унесите број воза у систем да бисте видели релевантне информације о возу. Овде су приказане само информације које су присутне на веб локацији. Оператор читања је ово. Међутим, ако желимо да резервишемо карту, морамо да попунимо формулар за резервацију улазница са детаљима као што су наше име, године и тако даље. Дакле, овде ћемо извршити операцију писања. Доћи ће до неких прилагођавања ИРЦТЦ база података .
Проблем је у томе што неколико људи истовремено покушава да приступи ИРЦТЦ база података . Они могу бити а писац или а читалац . Проблем настаје ако читач већ користи базу података и писац јој приступа истовремено да би радио на истим подацима. Други проблем се јавља када писац користи базу података, а читалац приступа истим информацијама као и бази података. Треће, постоји потешкоћа када један писац ажурира базу података док други покушава да ажурира податке у истој бази података. Четврти сценарио се дешава када два читаоца покушавају да пронађу исти материјал. Сви ови проблеми настају ако читач и писац користе исте податке базе података.
Семафор је метода која се користи за решавање овог проблема. Хајде да погледамо илустрацију како користити ово питање.
Процес читања:
#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;> Објашњење:
У овом коду имамо дељене променљиве податке и број читалаца рц . Тхе врт стање променљива се користи за ограничавање приступа за процес писца , анд тхе мутек се користи да гарантује узајамно искључење за приступ заједничким подацима.
Читачки процес је представљен функција читач(). . Тхе број читалаца (рц) се повећава пре постизања мутек закључавање . Користи птхреад_цонд_ваит() чекати на врт стање променљива ако је први читач (рц == 1) . Као резултат тога, писцима ће бити онемогућено да пишу док сви читаоци не заврше.
Процес читача проверава да ли је то био последњи читач (рц == 0) и спушта читаоца бројати (рц--) након читања заједничких података. Ако је, птхреад_цонд_сигнал() сигнализира врт стање променљива да би се процеси писача који чекају могли наставити.
Помоћу птхреад_цреате() и функције птхреад_јоин(). , ми Нова и придружити више нити читача у основна функција . Појединачни ИД се додељује свакој нити читача ради идентификације.
Процес писца:
wait(wrt); . . WRITE INTO THE OBJECT . signal(wrt);
У горњем примеру, исто као и процес читања , операција позната као операција чекања се изводи 'врт' када корисник жели да приступи подацима или објекту. Након тога, нови корисник неће моћи да приступи објекту. А када корисник заврши са писањем, извршава се друга сигнална операција врт .
2. проблем закључавања и откључавања:
Идеја а мутек се користи у вишенитности у Ц-у да гарантује да неће бити а услови трке између нити . Када више нити почне да обрађује исте податке одједном, ова околност је позната као трке . Међутим, ако те околности постоје, морамо. Користимо мутек'с лоцк() и унлоцк() функције да обезбедите одређени део кода за одређену нит. Тако да друга нит не може да почне да обавља исту операцију. Тхе 'критични одељак/регион' је назив дат овом заштићеном кодном подручју. Пре коришћења заједничких ресурса, постављамо много у одређеном подручју, а када завршимо са коришћењем, откључавамо их још једном.
Хајде да испитамо рад мутекса за закључавање и откључавање у вишенитном раду у Ц:
Пример:
#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;> Објашњење:
латекс величине текста
У овом горњем примеру објашњавамо како ми закључати и откључати одређени регион кода који нас штити од тркачке ситуације. 'птхреад_мутек_т' се користи као ан иницијализатор у горњем примеру. 'птхреад_мутек_лоцк' је тада писаним пре почетка кода који желимо да закључамо. Кодирање које желимо да закључамо је завршено након тога. Након тога, закључавање кода се прекида коришћењем 'птхреад_мутек_унлоцк' ; убудуће, ниједан код неће бити у закључаном режиму.
Проблем филозофа у ресторану:
Једно од класичних проблема са синхронизацијом је питање филозофа трпезарије . Једноставна алокација ресурса за неколико процеса је потребна, али не би требало да резултира а застој или глад . Тхе проблем филозофа у ресторану може се посматрати као директан приказ низа процеса, од којих сваки захтева ресурсе. Пошто сваки од ових процеса захтева алокацију ресурса, неопходно је дистрибуирати те ресурсе на све процесе тако да се ниједан процес никада не заглави или престане да ради.
Претпоставимо да пет филозофа седи у а сто у облику круга . У једном тренутку једу, а у другом размишљају о нечему. Око округлог стола, филозофи су равномерно распоређени на столицама. Поред тога, на средини стола налази се чинија пиринча и пет штапића за сваког филозофа. Када филозоф осети да не може да комуницира са својим колегама који седе у близини.
Филозоф повремено узме два штапића за јело када огладни. Она бира два штапића од својих комшија - један на њој лево а један на њој јел тако - који су на дохват руке. Али филозоф никада не би требало да узме више од једног штапића за јело одједном. Она очигледно неће моћи да узме штапић за јело који користи комшија.
Пример:
Хајде да употребимо пример да покажемо како се ово имплементира у Ц.
#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;> Објашњење:
нат вс бед
Штапићи за јело може бити представљен семафором. Пошто постоје штапићи за јело на столу и ниједан филозоф није изабрао ниједну, све компоненте штапића се прво иницијализују на 1 . Сада када штап за јело[и] је изабран као први штапић за јело. штап за јело[и] и штапић за јело[(и+1)%5] подлежу првој операцији чекања. Ове операција чекања штапића за јело указује да их је филозоф покупио. Процес исхране почиње када филозоф одабере своје штапић за јело . Операција сигнала се сада изводи на штапићи за јело [и] и [(и+1)%5] када филозоф заврши са јелом. Филозоф се затим враћа у сан.
Да би се утврдило да ли је субтхреад придружио се главној нити или не, користили смо функција птхреад_јоин . Слично, проверили смо да ли је мутек закључавање је иницијализовано помоћу птхреад_мутек_инит методом.
Да бисмо иницијализовали и проверили да ли је нова нит креирана или не, користили смо функција птхреад_цреате . Слично овоме, уништили смо мутек закључавање помоћу птхреад_мутек_дестрои функција.
Проблем произвођача и потрошача:
Уобичајени проблем са синхронизацијом процеса са више нити је проблем произвођача и потрошача . У њему су присутна два процеса: први је производни процес , а други је процес потрошача . Штавише, претпоставља се да се обе операције одвијају истовремено и паралелно. Поред тога, они су кооперативни процес, што имплицира да деле нешто једни са другима. Важно је да када је бафер пуна , произвођач не може да додаје податке. Када је бафер празан, потрошач не може да извуче податке из бафера јер је заједничка величина бафера између произвођача и потрошача фиксно . Питање је овако постављено. Дакле, да бисмо имплементирали проблем произвођач-потрошач и решили га, користићемо идеју паралелног програмирања.
Пример:
#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); } Излаз:
1. producer 2. consumer 3. for exit Please enter your choice:
Објашњење:
Обављамо два задатка. Функције потрошач() и продуцент() указују на статус и рад потрошача и продуцент . Тхе произвођач() метода ће створити мутек закључавање и утврди да ли је бафер пуна када се зове. Када је бафер пун, ништа се неће производити. Ако не, хоће Креирај , а затим, након производње , успаваће се да откључа мутек закључавање . Као продуцент , потрошач прво ствара мутек закључавање , проверава тампон , конзумира производ , а затим отпушта закључавање пре него што се врати у спавање.
А бројач (к) ће се користити током производње и наставиће да расте све док произвођач не произведе артикал. Међутим, потрошач ће производити мање исте произведене ставка (к) .
Закључак:
Идеја коришћења два или више нити за извршавање програма је познато као мултитхреадинг у програмском језику Ц. Мултитхреадинг омогућава истовремено извршавање више задатака. Најједноставнија извршна компонента програма је а конац . Процес је идеја да се задатак може завршити разбијањем на неколико мањих подпроцеси .
Датотека заглавља птхреад.х је неопходан да би се имплементирало вишенитност у Ц пошто се то не може урадити директно.