1 / 16

Конкурентно Програмиране

Конкурентно Програмиране. Семафори: използване за решаване на основни синхронизационни проблеми. Задача за обядващите философи.

kaya
Télécharger la présentation

Конкурентно Програмиране

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Конкурентно Програмиране Семафори: използване за решаване на основни синхронизационни проблеми Конкурентно програмиране 2005

  2. Задача за обядващите философи • Постановка на задачата: Петима философи прекарват времето си като мислят или се хранят. Последното правят около кръгла маса, в средата на която е поставена купа със спагети. Пред всеки философ има чиния, а между всеки две чинии – една вилица. За да може да яде спагети, всеки философ се нуждае от две вилици, като има право да ползва тези, които са от двете страни на неговата чиния. • Тук трябва да се решат следните синхронизационни проблеми: - всяка вилица да се използва най-много от един философ; - да не се допуска deadlock, т.е. да се окаже, че всеки философ е взел една вилица и чака да се освободи втората, което никога няма да стане; - да е гарантирано, че никой философ няма да умре от глад. • Илюстрация на проблема за възникването на deadlock: • Процесите са вdeadlock ако чакат събитие, което никога няма да настъпи. Най-чесно възникването на deadlock се свързва с управление на ресурсите. Конкурентно програмиране 2005

  3. Необходими условия за възникване на deadlock: - Монополен достъп до ресурсите; - Процесът държи едни ресурси докато чака да получи други; - Ресурсите не могат да бъдат отнемани насилствено от процес, който ги държи чакайки; - Има затворен кръг от процеси, всеки от които държи ресурс, искан от следващия процес в кръга. - Едновременно наличие на горните условия. • Техниките за предпазване от възникването на deadlockса основани на нарушаване на някое от тези условия. • Техниките за избягване на deadlockсе състоят в мониториране на разпределението на ресурсите така, че да се открива потенциалната поява на deadlock и да се предотвратява. Конкурентно програмиране 2005

  4. Решение на задачата за обядващите философи със семафори • Първо решение: общ ресурс е всяка една от вилиците, съответно нейната употреба се обявява за КУ и се защитава с отделен семафор. Semaphore fork [5] = {1,1,1,1,1}; Process Philosopher_i while (true) { think(); P.fork[i]; P.fork[(i+1)%5]; eat(); V.fork[i]; V.fork[(i+1)%5]; } End Philosopher_i; • При каква последователност от изпълнения на действията на процесите възниква deadlock? Конкурентно програмиране 2005

  5. Възможни решения за предпазване от възникването на deadlock: - да се получават едновременно двете вилици; - да се разкъса кръга от процеси, всеки от които е заел единия ресурс и чака достъп до другия: - един от процесите да размени реда, в който се опитва да вземе вилиците, например като всеки посяга първо към вилицата с по-малък номер; - процесите с четни номера да вземат първо лявата си вилица, а тези с нечетни номера – първо дясната; - да се ограничи броя на едновременно седящите около масата философи до 4. Това може да стане за сметка на добавяне на още един семафор-брояч, който управлява достъпа до масата: Semaphore table = 4; Process Philosopher_i P.table; . . . . . . . V.table; end Philosopher_i Конкурентно програмиране 2005

  6. Задача Читатели/Писатели • Модел на работа с общи дани – конкурентно изпълнение на неограничен брой процеси: Читатели, които само четат данните и Писатели, които ги променят. • Изискванията са данните да не се ползват едновременно от: - двама Писатели; - Писател и Читатели. • Решенията имат за цел: - да подсигурят горните изисквания; - да не налагат недопустимо намаление на конкурентността. • Първо решение: Semaphore rw=1; Process Reader Process Writer P.rw; P.rw; readData(); writeData(); V.rw; V.rw; End Reader end Writer • Недопустимо ограничаване на конкурентния достъп до данните. Конкурентно програмиране 2005

  7. Второ решение – отслабване на ограничението: Semaphore rw=1, mutex=1; int nR=0; // number of active Readers Process Reader . . . . . . . . . P.mutex; nR++; if (nR==1) P.rw; V.mutex; readData(); P.mutex; nR--; if (nR==0) V.rw; V.mutex; . . . . . . . . End Reader Process Writer . . . . . . . . . P.rw; writeData(); V.rw; . . . . . . End Writer • Позволено е на повече Читатели да имат конкурентен достъп до данните. • Въпроси: - Как и къде блокират Читателите и Писателите? - Какво става при напускане на Писател? - Кой има приоритет? Конкурентно програмиране 2005

  8. Читатели/Писатели – предаване на щафетата • Предаване на щафетата – метод, който: - позволява да се решават различни синхронизационни проблеми; - води до решения, които лесно се променят така, че да се смени стратегията на планиране. • Определяме предикат, характеризиращ “добрите” и “лошите” състояния на системата. Нека nR - е броят на активните Читатели nW - е броят на активните Писатели “Лоши” състояния:(nR>0 && nW>0) || (nW>1) “Добри” състояния:RW: (nR=0 || nW==0) && (nW<=1) RW е глобален инвариант на системата Reader: < await (nW==0) nR++;> read < nR--; > Writer: < await (nR==0 && nW==0) nW++;> write < nW--; > Конкурентно програмиране 2005

  9. В < > са означени атомарни действия на процесите. • await(B) S;имасмисъл: условието В е гарантирано при изпълнението на S. • “Предаването на щафетата” използва SPB за осигуряване на ВИ, реализация на await(B) и контрол на реда, по който се събуждат блокираните процеси. • Въвежда се: - един двоичен семафор за контрол на достъпа до атомарните действия; - за всяко условие /гард/ В: - един семафор с начална стойност 0; - един брояч с начална стойност 0. Семафорите общо формират един SPB. int nR=0, nW=0; Semaphore entry=1, // CS control semR=0, // delay Readers semW=0; // delay Writers // SPB: 0<= entry+semR+semW<=1 int dR=0, // number of delayed Readers dW=0; // number of delayed Writers Конкурентно програмиране 2005

  10. Process Reader while (true) { // await (nW==0) => nR++ P.entry; if (nW>0) { dR++; V.entry; P.semR; } nR++; signal(); readData(); // nR— P.entry; nR--; signal(); } end Reader Process Writer while (true) { // await (nR==0 && nW==0) => nW++ P.entry; if (nR>0 || nW>0) { dW++; V.entry; P.semW; } nW++; signal(); writeData(); // nW— P.entry; nW--; signal(); } end Writer Конкурентно програмиране 2005

  11. Какво прави signal - решава на кого да предаде щафетата: - на следващ Читател; - на следващ Писател; - да я остави. signal() { // awaken a Reader? if (nW==0 && dR>0) { dR--; V.semR; } // awakan a Writer? else if (nR==0 && nW==0 && dW>0) { dW--; V.semW; } // put baton down else V.entry; } Конкурентно програмиране 2005

  12. Читатели/Писатели – Условен критичен участък resource Control: {int nR=0; boolean isWriting=false;} Process Writer with Control when (nR==0 & !isWritimg) do isWriting=true; writeData(); with Control when (true) do isWriting=false; End Writer; Process Reader with Control when (!isWritimg) do nR++; readData(); with Control when (true) do nR--; End Reader; Конкурентно програмиране 2005

  13. Задачата за спящия бръснар • Постановка на задачата: В бръснарски салон работи един бръснар и има няколко стола за чакащи. Посетител, който влезе в салона и види, че в момента бръснарят подстригва някого сяда и чака, а ако няма свободни столове си тръгва. Ако няма други клиенти, посетителят може да завари бръснаря да дреме, тогава го събужда и сяда за подстригване. Когато бръснарят свърши да подстригва един клиент, той го изпраща и кани следващия, ако има такъв, иначе сяда в стола си и задрямва. • Задачата е илюстрация на типа отношения клиент-сървер между конкурентните процеси. Взаимодействието на процесите – рандеву, носи името си от това, че два процеса трябва “да се срещнат” в дадена точка от своето изпълнение, за да могат да продължат коректно работата си с изпълнение на “общо действие”. Това става за сметка на забавяне на процеса, който първи е пристигнал на мястото на срещата. • Следва просто решение на задачата с използване на семафори за синхронизиране на процеса “бръснар” и процесите “посетители”. Semaphore mutex=1; // за взаимно изключване Semaphore customers=0, // бръснарят чака клиент barber=0; // клиентите чакат бръснар int numChairs= n, waiting=0;// брой чакащи клиенти Конкурентно програмиране 2005

  14. Задачата за спящия бръснар – решение със семафори Process Customer_i while (true) { P.mutex; // иска достъп до 'waiting' if (waiting<numChairs){ // ако има свободен стол - чака waiting++; // увеличава броя на чакащи клиенти V.customers; // събужда бръснаря, ако спи V.mutex; // освобождава достъпа до 'waiting' P.barber; // чака ако бръснарят не е свободен getHairCut(); // клиентът получава услугата } else V.mutex; // иначе напуска } end Customer; Process SleepingBarber while (true) { P.customers; // задрямва ако няма клиенти P.mutex; // иска достъп до 'waiting' waiting--; // намалява броя на чакщите клиенти V.barber; //бръснарят е готов да подстригва V.mutex; // освобождава 'waiting' cutHair(); // сърверът обслужва } end SleepingBarber; Конкурентно програмиране 2005

  15. Задача за разпределение на ресурси - Планировчик • Две основни операции: - заемане на ресурс: request(param) await (resource available) take units - освобождаване на ресурс: release(param) return units • Пример - Shortest-Job-Next Resource Allocator за единичен ресурс boolean free=true; release (pid) { if (process delayed) awaken one else free=true } request (pid, time) { await (free) take resource free=false} Конкурентно програмиране 2005

  16. boolean free=true; Semaphore entry=1, b [n]={[n] 0}; PriorityQueue q=new PriorityQueue(); request (time, pid) { P.entry; if (!free) { q.enqueue(time, pid); V.entry; P.b[pid]; } free=false; V.entry; } release (pid) { P.entry; if (!q.empty()) { pid=q.dequeue(); V.b[pid]; } else free=true; V.entry; } Конкурентно програмиране 2005

More Related