Какво представлява Concurrency в Java?
В днешния свят всичко се развива бързо. Винаги има поле за усъвършенстване във всяко и всичко. Така е и с нашия език за програмиране. Днес с нашите съвременни технологии очакваме нещата да се правят лесно и с бърза скорост. За правенето на няколко неща едновременно или за извършването на няколко неща едновременно възникна концепцията за едновременност. И така, какво всъщност е паралелността, каква е неговата употреба, защо това наистина е необходимо и много други. Ще се опитаме да засегнем подобни въпроси и да им отговорим в тази статия един по един. Така че нека да доведем нашата дискусия до един много основен общ раздел, който е определението за едновременност. В тази тема ще научим какво е Concurrency в Java.
Определение за едновременност?
И така, какво всъщност представлява едновременността? Е, за да отговорим на това, нека вземем общ сценарий. Да предположим, че докато четете тази статия, вие се опитвате да правите няколко неща едновременно, може би се опитвате да си направите бележка, може би се опитвате да я разберете или мислите някои неща. Така че с прости думи се опитвате да правите множество неща паралелно. Това означава едновременност. Паралелността е просто изпълнение на множество задачи успоредно една на друга. В тази статия ще обсъдим паралелността в обхвата на Java като език за програмиране.
Всъщност в Java или изобщо във всеки език за програмиране именно темата е отговорна за пренасянето на паралелността. Основната роля на тези теми е да улесняват паралелното изпълнение на задачите. Междувременно, нека имаме основно определение на нишката.
И така, какво е нишка?
Нишката е лек процес със собствен стек за повикване. Въпреки това, нишката има привилегия за достъп до споделени данни от други нишки, изпълняващи се по същия процес. В рамките на Java приложение можем да използваме много нишки за постигане на паралелна обработка или паралелност.
Сега да преминем към следващата ни тема, която е,
Паралелност в дефиницията на Java?
Така че в Java или всеки друг език за програмиране като C # и т.н., всички езици на OOP имат понятие за нанизване на резба. В Java имаме различни процеси, които се изпълняват, като правим различни нишки, за да постигнем едновременност
Така че след това просто определение, нека обсъдим нашата нова тема, която е:
Какво прави прилагането на Java едновременно?
Първият клас, който трябва да направи едновременно приложение на Java, е клас java.lang.Thread. java.lang.Thread класът отговаря за всички концепции за съвместност в програмния език на Java. След това имаме java.lang.Runnable интерфейс, за да абстрахираме поведението на нишката от класа на нишката.
Другият клас, който ще ни е необходим за изграждането на разширено приложение, ще бъде използван от пакета java.util.concurrent, добавен в Java 1.5.
Сега с това стигнахме до нов въпрос, който е:
Наистина ли е толкова лесно Java Concurrency?
Тъй като изглежда, че прилагането на паралелността в Java е доста проста. Обаче наистина не е така. Нека се погрижим.
Горната ни дискусия като цяло създава впечатление, че паралелността наистина е проста, добра концепция и доста лесна за изпълнение. Е, ако наблюдаваме по по-добър начин и се опитаме да го разберем, установяваме, че това изисква добро разбиране на основните понятия, както и задълбочено разбиране на това, което трябва да постигнем.
Ако сравняваме едновременни приложения и едно резбовано приложение, обикновено установяваме, че едновременното приложение е сложно по отношение на проектирането и разбирането. Кодът, изпълнен от множество нишки, изисква специално внимание и ресурси за достъп до споделени данни. Грешки изскачащи поради неправилна синхронизация на нишката е трудно да се отстранят грешки и да се поправят. Също така, в повечето от сценариите тези грешки не се идентифицират в началната фаза, всъщност те се откриват в режим на prod, който е още по-труден за възпроизвеждане.
Освен грешки и често срещани дефекти, паралелните нишки изискват още ресурси за стартиране на приложението
Проблеми и подобряване на паралелността - Обяснение с пример
Така че в общи линии има два вида проблеми, които се задават поради едновременност. Тези проблеми могат да бъдат широко класифицирани в две категории
- Грешки при смущения на нишката
- Грешки в консистенцията на паметта
Нека разберем всеки един по един
Грешки в намесата на нишката - Нека разберем с прост пример.
Да предположим, че имаме функция на брояч, чиято основна роля е да увеличи брояча или да преброи число. Сега нека предположим, че имаме две нишки, нишка A и нишка B. Да предположим, че нишка A чете първоначалната стойност като 0. Сега следващите стъпки се изпълняват последователно.
- Тема А чете началната стойност като 0
- Нишката B чете началната стойност като 0
- Тема Увеличете стойността с 1. Новата стойност вече е 1
- Нишката B също паралелно увеличава стойността до 1.
- Тема A записва актуализирана стойност, която е 1 в клетката на паметта
- Нишката B също повтаря същата стъпка, която е записана в актуализирана стойност на клетката с памет 1
Така че тук възниква проблемът. Две нишки A & B, изпълнете кода два пъти и очакваната стойност е 2, но това, което е отразено е 1. Това е основният проблем, който могат да причинят множество теми
Как това би могло да се реши?
Грешките на смущения на нишката могат да бъдат решени чрез синхронизиране на достъпа до споделени променливи. Трябва да поддържаме синхронизиране на актуализираните стойности между споделените данни
С това нека разгледаме втория тип грешка
Грешки в последователността на паметта
Грешките в несъвместимостта на паметта обикновено се появяват, когато различни нишки се опитват да четат или имат непоследователни мнения на една и съща част от данните. Това обикновено се случва, когато първата нишка актуализира някои споделени данни и тази актуализирана стойност не се разпространява във втора или различни нишки и те четат стари данни.
Нека видим защо това се случва?
Е, може да има много причини за това. Обикновено компилаторът прави много няколко оптимизации на приложението, за да подобри производителността. Той може също да актуализира последователности с инструкции, за да оптимизира производителността. Дори обикновено процесорите също се опитват да оптимизират кодовете, например, процесор може да чете текущата стойност на променлива от кеш паметта или временния регистър вместо от основната памет
Заключение - Какво представлява паралелността в Java?
Паралелността е много важна характеристика на всеки език на OOP. Концирането ни дава функцията да изпълняваме множество процеси паралелно един с друг. Помага ни по-бързо да изпълним сложната си задача. При плюсовете обаче, паралелността има и малко минуси. Използването на резба причинява интензивно използване на ресурси
Препоръчителни статии
Това е ръководство за това какво представлява паралелността в Java. Тук сме обсъдили с проблемите и подобренията в паралелността с пример. Можете да разгледате и другите ни предложени статии, за да научите повече -
- Какво е мултитройно четене в java?
- Как да свържете база данни в Java?
- Какво е мултитройно четене в java?
- Какво е J2EE?