Какво е заключване на паметта?

Исторически погледнато, всички компютърни програми са били написани по напълно последователен начин. Това е лесно за четене, писане и разбиране. Освен това е лесно за изпълнение от компютър и изисква сравнително прост хардуер. С тази дизайнерска парадигма единствените два начина за увеличаване на производителността на системата са да се напише по-ефективен код и да се увеличи скоростта на процесора. Повишаването на ефективността на кода може да е възможно, но обикновено това е сложен процес с често ограничени резултати.

В продължение на десетилетия производителността може да бъде намалена чрез изчакване на нови, по-ефективни процесори. Както е описано от закона на Мур, процесорите грубо удвояват производителността на всеки две до три години. За съжаление повечето от тези печалби в производителността идват от използването на все по-малки производствени възли. Съвременната технология се бори да намали размера на възела с историческата скорост, благодарение на материалните трудности при работа в мащаб на нанометри.

За да заобиколят това, модерните CPU архитекти са избрали да добавят множество процесорни ядра към CPU. Всяко процесорно ядро ​​може да действа независимо при различна задача. Въпреки че не могат да комбинират един и същ проблем, те могат да работят върху два проблема едновременно. Тази фундаментална архитектурна промяна осигурява много допълнителна производителност, но не облагодетелства директно отделните процеси, въпреки че намалява конкуренцията за процесорно време.

За да се възползвате от предимствата на многоядрените процесори, кодът трябва да бъде написан по многонишков начин. След това всяка нишка може да се изпълнява едновременно, мащабирайки ползата от производителността според броя на наличните нишки и процесорни ядра. Правейки това обаче, се натъквате на ново предизвикателство, „състезателното състояние“.

Забележка: Някои задачи не могат да бъдат многонишкови, докато други могат да бъдат масово многонишкови. Възможните ползи от производителността наистина зависят от извършената работа.

Състезателни условия

Многонишковият софтуер може да се възползва от множество ядра. В тези води дебнат опасности, готови да хванат в капан неопитния програмист. Състояние на състезание може да възникне, когато две различни нишки взаимодействат с един и същи бит памет.

Прост пример може да са две нишки, които се опитват да проверят и увеличат променлива едновременно. Да кажем, че a=0 . След това две различни нишки изпълняват своите функции и в даден момент проверяват a и го увеличават с едно. Като цяло бихте очаквали резултатът от две нишки, добавящи едно към нула, да бъде две. През повечето време това трябва да е така. Можете да получите различен резултат, ако и двете нишки преминат през тази специфична функционалност в точното време.

В този случай първата нишка чете стойността на . Преди първата нишка да може да увеличи стойността на все пак, втората нишка я чете. Сега първата нишка добавя едно към нула, но втората нишка вече вярва, че стойността е нула, добавяйки едно към нула. Резултатът от това е, че крайната стойност на a е 1, а не 2.

Състезание към най-лошия сценарий

Въпреки че примерът по-горе може да не звучи особено зле, той може да има драматичен ефект. Какво става, ако стойността на a избира режима на работа на машината? Ами ако определени режими на работа на тази машина могат да бъдат опасни или дори животозастрашаващи?

Състезателните условия също не трябва да бъдат толкова прости. Например, може да е възможно една нишка да чете секция от паметта по същото време, когато друга нишка пише в нея. В този случай нишката за четене може да получи странна комбинация от данни от преди и след. Да кажем, че проверката е проста проверка вярно/невярно.

Ако променливата каза true в началото на четенето, но беше в процес на презаписване на думата false, резултатът от операцията за четене може да бъде нещо като „trlse“. Това не е „вярно“ или „невярно“. Липсата на нито една от двете опции в двоичния избор почти сигурно ще доведе до срив на приложението. Тази повреда на паметта може да доведе до много проблеми със сигурността, като например отказ на услуга и ескалация на привилегии.

Заключване на състезанието

Знанието какви битове памет в една програма се споделят между различни нишки е от съществено значение за предотвратяване на състояние на състезание. Не е необходимо да се прави нищо, ако дадена променлива е контролирана и достъпна само от една нишка. Ако две или повече нишки имат достъп до променлива, тогава трябва да се уверите, че всички операции върху тази част от паметта са завършени независимо една от друга.

Тази независимост се постига благодарение на ключалка. В кода на програма трябва да поставите ключалка, когато пишете функция, която работи върху споделена част от паметта. Това заключване блокира други нишки от достъп до тази част от паметта, докато заключването не бъде освободено.

Ключалката не е най-елегантното решение. От една страна, има допълнителни разходи за памет. Също така може да принуди конец да виси, чакайки ключалката да бъде освободена. В зависимост от ситуацията ключалката може да не бъде освободена за много дълго време или изобщо да не бъде освободена. В най-лошия случай отключването на заключване може да зависи от нещо, което се случва в друга блокирана нишка, което води до блокиране.

От съществено значение е да оптимизирате използването на брави. Можете да контролирате колко гранулирана е ключалката. Например, ако редактирате данни в таблица, можете да заключите цялата таблица или само редактирания ред. Заключването на цялата таблица би било заключване с груба детайлност. Това минимизира режийните разходи от прилагането на твърде много заключвания, но увеличава шанса друга нишка да бъде блокирана от ключалката. Заключването само на реда би било фино заключване на детайлността. Това е много по-малко вероятно да пречи на други нишки, но означава, че ще са необходими разкъсани ключалки, което увеличава общите разходи.

Заключение

Заключването на паметта е кодов инструмент, който се използва за осигуряване на атомарни операции в паметта в многонишкова среда. Като заключите част от паметта, преди да работите с нея, можете да сте сигурни, че няма да възникне неочаквано поведение поради състояние на състезание. Заключванията на паметта идват с натоварване на паметта, но също така могат да причинят блокиране.

Блокирането е мястото, където друга нишка се опитва да работи върху заключена памет. Конецът стои там, блокиран, докато ключалката бъде освободена. Това може да причини проблеми, ако освобождаването на заключването изисква друга нишка да направи нещо, тъй като може да се блокира, преди да успее да изпълни предпоставката за освобождаване на заключването, което го блокира. Заключванията на паметта могат да бъдат избегнати чрез писане на неблокиращи кодове. Това обаче може да бъде сложно и по-малко ефективно от използването на ключалки. Не забравяйте да оставите вашите коментари по-долу.