Многопоточност в Java
Виртуалната машина на Java поддържа паралелни изчисления . Всички изчисления могат да се извършват в контекста на една or повече нишки. Можем лесно да настроим достъп до един и същ ресурс or обект за множество нишки, Howто и да настроим нишка за изпълнение на единичен блок code.
Всеки разработчик трябва да синхронизира работата с нишки по време на операции за четене и запис за ресурси, които имат множество разпределени нишки.
Важно е в момента на достъп до ресурса да имате актуални данни, за да може друга нишка да ги промени и да получите най-актуалната информация. Дори да вземем за пример банкова сметка, докато парите не постъпят по нея, не можете да я използвате, така че е важно данните винаги да са актуални. Java има специални класове за синхронизиране и управление на нишки.
Нишки обекти
Всичко започва с основната (основната) нишка, тоест поне вашата програма вече има една работеща нишка. Основната нишка може да създава други нишки с помощта на Callable or Runnable . Създаването се различава само по върнатия резултат, Runnable не връща резултат и не може да хвърли проверено изключение. Следователно получавате добра възможност за изграждане на ефективна работа с файлове, но това е много опасно и трябва да внимавате.
Възможно е също така да планирате изпълнение на нишка на отделно ядро на процесора. Системата може лесно да се движи между нишки и да изпълни конкретна нишка с правилните настройки: т.е. нишката, която чете данните, се изпълнява първа, веднага щом имаме данни, след това ги предаваме на нишката, която отговаря за валидирането, след това го предаваме на нишката, за да изпълни няHowва бизнес логика и нова нишка ги записва обратно. В такава ситуация 4 нишки обработват данни на свой ред и всичко ще работи по-бързо от една нишка. Всеки такъв поток се преобразува в собствен поток на операционната система, но How ще бъде преобразуван зависи от изпълнението на JVM.
Класът Thread се използва за създаване и работа с нишки. Има стандартни контролни механизми, Howто и абстрактни, като класове и колекции от java.util.concurrent .
Синхронизиране на нишки в Java
Комуникацията се осигурява чрез споделяне на достъп до обекти. Това е много ефективно, но в същото време е много лесно да се направи грешка при работа. Грешките идват в два случая: намеса на нишка - когато друга нишка пречи на вашата нишка и грешки в консистенцията на паметта - консистенция на паметта. За да разрешим и предотвратим тези грешки, имаме различни методи за синхронизиране.
Синхронизирането на нишки в Java се управлява от монитори, това е механизъм на високо ниво, който позволява само на една нишка да изпълни блок от code, защитен от същия монитор в даден момент. Поведението на мониторите се разглежда от гледна точка на ключалки; един монитор - една ключалка.
Синхронизацията има няколко важни момента, на които трябва да обърнете внимание. Първата точка е взаимно изключване - само една нишка може да притежава монитора, като по този начин синхронизирането на монитора предполага, че след като една нишка влезе в синхронизиран блок, защитен от монитора, никоя друга нишка не може да влезе в блока, защитен от монитора. този монитор, докато първата нишка излиза от синхронизирания блок. Тоест множество нишки не могат да имат достъп до един и същ синхронизиран блок едновременно.
Но синхронизирането не е само взаимно изключване. Синхронизирането гарантира, че данните, записани в паметта преди or в рамките на синхронизиран блок, стават видими за други нишки, които са синхронизирани на същия монитор. След като излезем от блока, освобождаваме монитора и друга нишка може да го вземе и да започне да изпълнява този блок от code.
Когато нова нишка заснеме монитора, ние получаваме достъп и възможност да изпълним този блок от code и в този момент променливите ще бъдат заредени от основната памет. След това можем да видим всички записи, напequalsи видими от предишната version на монитора.
Четене-запис върху поле е атомарна операция, ако полето е обявено за летливо or защитено от уникално заключване, придобито преди всяко четене-запис. Но ако все пак срещнете грешка, тогава получавате грешка за пренареждане (промяна на реда, пренареждане). Проявява се в неправилно синхронизирани многонишкови програми, където една нишка може да наблюдава ефектите, които се произвеждат от други нишки.Ефектът на взаимно изключване и синхронизиране на нишките, тоест тяхната правилна работа, се постига само чрез въвеждане на синхронизиран блок or метод, който имплицитно получава заключване, or чрез изрично получаване на заключване. Ще говорим за това по-долу. И двата начина на работа засягат паметта ви и е важно да не забравяте работата с непостоянни променливи.
Променливи полета в Java
Ако дадена променлива е означена като volatile , тя е достъпна глобално. Това означава, че ако нишка има достъп до променлива променлива, тя ще получи нейната стойност, преди да използва стойността от кеша.
Записването работи като освобождаване на монитор, а четенето работи като улавяне на монитор. Достъпът се осъществява в релация от типа „извършено преди“. Ако го разберете, всичко, което ще бъде видимо за нишка A, когато има достъп до променлива променлива, е променливата за нишка B. Това означава, че гарантирано няма да загубите промените си от други нишки.
Летливите променливи са атомарни, т.е. при четене на такава променлива се използва същият ефект, Howто при получаване на заключване - данните в паметта се обявяват за невалидни or неправилни и стойността на летливата променлива отново се чете от паметта . При запис се използва ефектът върху паметта, Howто и при освобождаване на заключване - в паметта се записва летливо поле.
Java Concurrent
Ако искате да направите супер-ефективно и многонишково приложение, трябва да използвате класовете от библиотеката JavaConcurrent , които са в пакета java.util.concurrent .
Библиотеката е много обемна и има различна функционалност, така че нека да разгледаме Howво има вътре и да го разделим на няколко модула:
Concurrent Collections е набор от колекции за работа в многонишкова среда. Вместо основната обвивка Collections.synchronizedList с блокиране на достъпа до цялата колекция, се използват ключалки на сегменти от данни or се използват алгоритми без изчакване за паралелно четене на данни.
Опашки - неблокиращи и блокиращи опашки за работа в многонишкова среда. Неблокиращите опашки се фокусират върху скоростта и работата, без да блокират нишки. Опашките за блокиране са подходящи за работа, когато трябва да „забавите“ нишките на производителя or потребителя . Например, в ситуация, в която някои от условията не са изпълнени, опашката е празна or пълна, or няма свободен Consumer 'a.
Синхронизаторите са помощни програми за синхронизиране на нишки. Те са мощно оръжие в "паралелните" изчисления.
Executors е рамка за по-удобно и лесно създаване на пулове от нишки, лесно е да се настрои планиране на асинхронни задачи с получаване на резултати.
Заключванията са много гъвкави механизми за синхронизиране на нишки в сравнение с основните синхронизирани , изчакайте , уведомете , уведометеВсички .
Atomics са класове, които могат да поддържат атомни операции върху примитиви и референции.