От началото на езеците за програмиране насам обработката на грешките е била винаги един от най-трудните моменти. Тъй като е толкова трудно да се направи добра схема за обработка на грешки, много езици просто игнорират този въпрос, предавайки проблема на разработчиците на библиотеки, които пък вземат половинчати мерки, въвршещи в много случаи работа, но които могат лесно да бъдат провалени, изобщо просто като бъдат игнорирани самите те. Главният проблем на повечето схеми за обработка на грешки е, че те се основават на бдителността на програмиста за спадване на приета схема, която не е наложена от самия език. Ако програмистът не е бдителен, каквито често биват те, когато бързат, схемата лесно може да бъде забравена.
Обработката на изключения връзва обработката на грешки направо в езика и даже операционната система. Изключението е обект, който е “изхвърлен” от частта на грешката и може да бъде “хванат” от подходящ обработчик на изключения проектиран да обработи съотватния конкретен тип грешка. Сякаш обработката на изключения е друг, паралелен път, който пресмятанията могат да поемат, ако нещата се сбъркат. И понеже то използва друг път на изпълнение, не е необходимо да си пречи с вашия код, който не се занимава с грешки. Това прави кодирането по-просто, понеже не сте принудени постоянно да проверявате за грешки. В добавка изхвърленото изключение не прилича на върната стойност на грешката от функция или флаг сложен от функция с цел да отбележи наличието на грешка, те могат да бъдат игнорирани. Изключението не може да бъде игнорирано, така че ще му дойде времето в някой момент. Накрая, изключенията дават начин надеждно да се излезе от лошата ситуация. Наместо просто да излезете (да завърши програмата - б.пр.) често може нещата да се оправят и изпълнението да продължи, което довежда до много по-добри програми.
Обработката на изключения в Java изпъква сред останалите езици, понеже тук то е вградено от самото начало и потребителят на езика е принуден да го използва. Ако не си направите програмата да обработва правилно изключения, получавате грешки при компилация. Тази гарантирана състоятелност прови обработката на грешки много по-лесна.
Нищо не пречи че обработката на изключения не е ОО черта, макар и в ООП езиците изключението да е представено обикновено с обект. Обработката на изключения съществува от преди ООП.
Многонишково изпълнение
Основна идея в компютърното програмиране е изпълняването на повече от една задача едновременно. Много програмни проблеми изискват възможността програмата да може да спре текущото изпълнение, да свърши нещо друго и да се върне към основната си задача. Много подходи е имало за решението. Първоначално програмисти с познаване на машината на ниско ниво писали програми за обслужване на прекъсванията и отклонението от главния процес се започвало с хардуерно прекъсване. Въпреки че работело добре, това било трудно и непреносимо, така че правело преместването на протрамата на нов тип машина скъпо и бавно.
Понякога прекъсванията са важни за критични задачи,у но в повечето случаи се иска просто задачата да се раздели на конкурентно работещи парчета, които съвместно да я правят по-диалогична. В рамките на програмата тези отделно работещи процеси се наричат нишки и основната концепция се нарича многонишковост. Общ пример за многонишковост е потребителският интерфейс. Чрез използването на многонишковост потребителят може да натисне бутон и да получи бърз отговор, наместо да чака завършването на цялата работа.
Както обикновено, нишките са само начин да се ангажира време от един процесор. Когато операционната система поддържа повече от един процесор и такива са налични, всяка нишка може да се изпълнява на отделен процесор и паралелно с другите. Едно от удобните неща на мултитрединга е, че програмистът на високо ниво не е необходимо да се грижи дали процесорите са много или само един. Програмата логически се разделя на нишки и ако има повече от един процесор, тя просто работи по-бързо.
Всичко това прави нишките да звучат доста прости. Има клопка: разделяемите ресурси. Ако има повече от една нишка, която се нуждае от даден ресурс, имате проблем. Например не може два процесора едновременно да подават информация към принтер. За да се реши проблемът ресурсите, които трябва да се споделят, като принтера, трябва да бъдат заключени по време на използването им. Така че нишката заключва ресурса, свършва си работата и го отключва, така че друга да може да го използва.
Нишковостта е вградена в Java, което прави сложният проблем много по-прост. Нишковостта се поддържа на обектно ниво, така че нишката се представя с обект. Java също осигурява заключване на ресурси с определени ограничения. Може да заключва паметта на всеки обект (която памет е, в края на краищата, разделяем ресурс) така че само една нишка да я използува едновременно. Това се постига с ключовата дума synchronized. Другите ресурси трябва да се заключват явно от програмиста, типично чрез създаване на обект, който представя ключалката и трябва да бъде пробван преди ресурсът да се използва.
Упоритост
Като се създаде обект, той съществува, колкото е необходим, но по никакъв начин след завършването на програмата. Докато на пръв поглед това има смисъл, има и ситуации, в които би било чудесно обектът да си запазва стойностите и когато програмата не работи. При следващо стартиране на програмата такъв обект ще съдържа същата информация, каквато при предишното е получил. Разбира се, това би могло да се постигне чрез писане на файлове, например бази данни, но в цялостния дух на ООП всичко да е обекти просто трябва да се направи обект, който е упорит (понякога - устойчив, б.пр.)и да се грижи за всички детайли вместо програмиста.
Java 1.1 поддържа “лека упоритост,” което означава, че лесно може да запомняте и възстановявате обекти. Причината да е “лека” е, че все още трябва явно да се викат функции за запомнянето и възстановяването. В някоя бъдеща версия може да се появи по-пълно обслужване на "упоритост".
Сподели с приятели: |
