Известно е, че C ++ е един от най-бързите езици за програмиране с добра производителност, висока точност и адекватна система за управление на паметта. Този език за програмиране също поддържа едновременното изпълнение на множество нишки със споделянето на множество ресурси между тях. При многопоточност нишката е само за извършване на операция за четене, която не създава проблеми, тъй като нишката не се влияе от това, което другите нишки правят по това време. Но ако тези нишки трябваше да споделят ресурсите помежду си, една нишка може да промени данните по това време, което прави проблема. За да се справим с този проблем, имаме C++ „Mutex“, който предотвратява достъпа на множество ресурси до нашия код/обект чрез предоставяне на синхронизация, която гласи, че достъпът до обекта/кода може да бъде предоставен само на една нишка наведнъж, така че множество нишки няма да имат достъп до този обект едновременно.
Процедура:
Ще разберем как можем да спрем достъпа на множество нишки до обект наведнъж, като използваме заключване на mutex. Ще говорим за синтаксиса на заключването на mutex, какво представлява множествената резба и как можем да се справим с проблемите, причинени от множествена резба, използвайки заключването на mutex. След това ще вземем пример за множество нишки и ще имплементираме заключването на mutex.
Синтаксис:
Ако искаме да научим как можем да приложим заключването на mutex, така че да предотвратим достъпа на множество нишки едновременно към нашия обект или код, можем да използваме следния синтаксис:
стандартни $ :: мютекс mut_x
$ mut_x. ключалка ( ) ;
Невалидно име на функция ( ) {
$ // кодът, който искаме да скрием от множеството нишки, ще бъде написан тук
$ mut_x. отключва ( ) ;
}
Сега ще използваме този синтаксис във фиктивния пример и в псевдо кода (който не можем просто да изпълним така, както е в редактора на код), за да ви уведомим как точно можем да използваме този синтаксис, както е споменато по-долу:
стандартни $ :: мютекс mut_x
Празен блок ( ) {
$ mut_x. ключалка ( ) ;
стандартни $ :: cout << 'Здравейте' ;
$ mut_x. отключва ( ) ;
}
Пример:
В този пример, нека се опитаме първо да създадем многонишкова операция и след това да обградим тази операция със заключване и отключване на mutex, за да осигурим синхронизиране на операцията към създадения код или обект. Mutex се занимава с условия на състезание, които са стойности, които са доста непредвидими и зависят от превключването на нишките, които са съобразени с времето. За да приложим примера за mutex, първо трябва да импортираме важните и необходими библиотеки от хранилищата. Необходимите библиотеки са:
$ # включват
$ # включват <нишка>
$ # включват
Библиотеката „iostream“ ни предоставя функция за показване на данните като Cout, четене на данните като Cin и прекратяване на израза като endl. Използваме библиотеката „нишка“, за да използваме програмите или функциите от нишките. Библиотеката „mutex“ ни позволява да внедрим както заключването, така и отключването на mutex в кода. Използваме „# включване“, защото това позволява всички програми, свързани с библиотеката, включени в кода.
Сега, след като предишната стъпка е направена, ние дефинираме класа на mutex или глобална променлива за mutex, използвайки std. След това създаваме функция за заключване и отключване на mutex, която можем да извикаме след това в кода. В този пример ние наричаме тази функция като блок. В тялото на блоковата функция първо извикваме „mutex.lock()“ и започваме да пишем логиката на кода.
Mutex.lock() отказва достъпа на другите нишки за достигане до нашия създаден обект или код, така че само една нишка може да чете нашия обект наведнъж. В логиката изпълняваме for цикъл, който работи на индекса от 0 до 9. Показваме стойностите в цикъла. След като тази логика бъде създадена в заключването на mutex, след като операцията е извършена или след излизане от логиката, ние извикваме метода „mutex.unlock()“. Това извикване на метод ни позволява да отключим създадения обект от заключването на mutex, тъй като достъпът на обекта до една единствена нишка е предоставен по-рано и след като операцията върху този обект се извърши от една нишка наведнъж. Сега искаме и другите нишки да имат достъп до този обект или код. В противен случай нашият код се движи в ситуация на „безизходица“, което кара създадения обект с мютекса да остане завинаги в заключената ситуация и никоя друга нишка няма да има достъп до този обект. Следователно незавършена операция продължава да се изпълнява. След това излизаме от блоковата функция и преминаваме към основната.
В основния, ние просто показваме нашия създаден mutex, като създаваме трите нишки, използвайки „std :: thread thread_name (извикване на вече създадената блокова функция тук, в която създадохме mutex)“ с имената thread1, thread2 и thread3 и т.н. По този начин се създават трите нишки. След това съединяваме тези три нишки, за да бъдат изпълнени едновременно, като извикаме „име_на_нишка. join ()” метод. И след това връщаме стойността, равна на нула. Споменатото по-горе обяснение на примера е реализирано под формата на код, който може да бъде показан на следната фигура:
В изхода на кода можем да видим изпълнението и показването на трите нишки един по един. Можем да видим дори дали приложението ни попада в категорията на многопоточност. Все пак никоя от нишките не е презаписала или модифицирала данните и не е споделила модифицирания ресурс поради внедряването на mutex на „функционалния блок“.
Заключение
Това ръководство дава подробно обяснение на концепцията на функцията mutex, използвана в C++. Обсъдихме какво представляват многонишковите приложения, какви проблеми трябва да срещаме в многонишковите приложения и защо трябва да внедрим mutex за многонишкови приложения. След това обсъдихме синтаксиса за mutex с фиктивния пример, използвайки псевдокода. След това внедрихме пълен пример за многонишкови приложения с mutex в C++ визуалното студио.