Java 2. Techniki zaawansowane. Wydanie II

1. IDZ DO PRZYK£ADOWY ROZDZIA£ Java 2. Techniki SPIS TRE CI zaawansowane. KATALOG KSI¥¯EK Wydanie II Autorzy: Cay Horstmann, Gary Cornell KATALOG ONLINE T³umaczenie: Jaromir Senczyk ISBN: 83-7361-842-2 ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Core Java(TM) 2, Volume II — Advanced Features (7th Edition) Format: B5, stron: 1144 TWÓJ KOSZYK Przyk³ady na ftp: 1644 kB DODAJ DO KOSZYKA Kompletne i niezast¹pione ród³o wiedzy dla do wiadczonych programistów • Kolejne wydanie doskona³ego przewodnika po zaawansowanych mo¿liwo ciach Javy • Wszystkie kody ród³owe w ksi¹¿ce zaktualizowane do J2SE 5.0 CENNIK I INFORMACJE • Szczegó³owe omówienie wielow¹tkowo ci, kolekcji, programowania aplikacji sieciowych i bazodanowych, bezpieczeñstwa i internacjonalizacji aplikacji, ZAMÓW INFORMACJE obiektów rozproszonych i jêzyka XML O NOWO CIACH Kolejne ju¿ wydanie przewodnika opisuj¹cego zaawansowane i nieznane w³a ciwo ci jêzyka Java, tym razem w wersji 5.0, to kompendium wiedzy dla wszystkich programistów ZAMÓW CENNIK zamierzaj¹cych tworzyæ rozbudowane aplikacje. Nowa wersja jêzyka Java to nie tylko nowy numer -- to przede wszystkim ogromna ilo æ nowych funkcji i mo¿liwo ci, klas i obiektów. W JDK 5.0 wprowadzono nowe mechanizmy obs³ugi w¹tków i kolekcji, rozszerzono CZYTELNIA mo¿liwo ci biblioteki Swing i klas wykorzystywanych do tworzenia aplikacji bazodanowych i sieciowych. „Java 2. Techniki zaawansowane. Wydanie II” przedstawia i opisuje wszystkie FRAGMENTY KSI¥¯EK ONLINE te nowo ci. Wszystkie przyk³adowe programy zosta³y zaktualizowane do najnowszej wersji Javy i przedstawiaj¹ praktyczne rozwi¹zania rzeczywistych problemów, z jakimi mo¿e spotkaæ siê twórca aplikacji w jêzyku Java. Ksi¹¿ka zawiera wiele nowych podrozdzia³ów po wiêconych nowo ciom wprowadzonym w J2SE 5.0. Dok³adnie i na przyk³adach opisuje zagadnienia zwi¹zane z wielow¹tkowo ci¹, kolekcjami, metadanymi, stosowaniem jêzyka XML, komunikacj¹ z bazami danych i wieloma innymi elementami zaawansowanego programowania w Javie. • Aplikacje wielow¹tkowe • Kolekcje i operacje na nich • Po³¹czenia sieciowe Wydawnictwo Helion • Interfejs JDBC i LDAP ul. Chopina 6 • Aplikacje rozproszone 44-100 Gliwice • Technologia CORBA tel. (32)230-98-63 • Zaawansowane mo¿liwo ci bibliotek Swing i AWT e-mail: helion@helion.pl • Technologia JavaBeans • Bezpieczeñstwo aplikacji • Internacjonalizacja • Korzystanie z jêzyka XML Je li zamierzasz wykorzystaæ Javê w z³o¿onym projekcie informatycznym, ta ksi¹¿ka bêdzie dla Ciebie niezast¹piona.

2. Spis treści Podziękowania........................................................................................................................................... 11 Przedmowa............................................................................................................................................... 13 Do Czytelnika.............................................................................................................. 13 O książce ................................................................................................................... 13 Rozdział 1. Wielowątkowość .................................................................................................................... 17 Czym są wątki? ........................................................................................................... 18 Zastosowanie wątków............................................................................................. 23 Przerywanie wątków..................................................................................................... 29 Stany wątków ............................................................................................................. 32 Nowe wątki ........................................................................................................... 32 Wątki wykonywalne................................................................................................. 33 Wątki zablokowane................................................................................................. 33 Wątki martwe ........................................................................................................ 35 Właściwości wątków .................................................................................................... 36 Priorytety wątków ................................................................................................... 36 Wątki-demony ........................................................................................................ 37 Grupy wątków ........................................................................................................ 37 Procedury obsługi wyjątków ..................................................................................... 39 Synchronizacja............................................................................................................ 40 Przykład wyścigu .................................................................................................... 41 Wytłumaczenie wyścigu........................................................................................... 45 Blokady................................................................................................................. 46 Warunki ................................................................................................................ 49 Słowo kluczowe synchronized .................................................................................. 54 Bloki synchronizowane............................................................................................ 60 Pola volatile .......................................................................................................... 61 Zakleszczenia ........................................................................................................ 63 Równorzędne traktowanie wątków............................................................................ 65 Testowanie blokad i limity czasu.............................................................................. 65 Blokady odczytu i zapisu ......................................................................................... 67 Dlaczego metody stop i suspend nie są zalecane? .................................................... 68 Kolejki blokujące ......................................................................................................... 70 Kolekcje..................................................................................................................... 76 Efektywne implementacje kolejki i tablicy mieszającej ................................................ 76 Kolekcje CopyOnWriteArrayList i CopyOnWriteArraySet................................................ 78 Starsze kolekcje i wielowątkowość ........................................................................... 78

3. 4 Java 2. Techniki zaawansowane Interfejsy Callable i Future............................................................................................ 78 Egzekutory.................................................................................................................. 83 Pule wątków .......................................................................................................... 83 Wykonywanie zadań według planu ............................................................................ 87 Sterowanie grupami wątków .................................................................................... 88 Synchronizatory........................................................................................................... 89 Bariery .................................................................................................................. 90 Rejestry odliczające................................................................................................ 91 Przekaźniki ............................................................................................................ 91 Kolejki synchroniczne ............................................................................................. 91 Semafory .............................................................................................................. 92 Wątki i Swing .............................................................................................................. 98 Zasada pojedynczego wątku .................................................................................... 99 Wątek roboczy i Swing .......................................................................................... 104 Rozdział 2. Kolekcje..................................................................................................................................111 Interfejsy kolekcji ...................................................................................................... 111 Rozdzielenie interfejsów kolekcji od ich implementacji.............................................. 112 Interfejsy Collection i Iterator w bibliotekach języka Java........................................... 114 Kolekcje konkretne.................................................................................................... 119 Listy powiązane ................................................................................................... 120 Klasa ArrayList .................................................................................................... 128 Zbiory z kodowaniem mieszającym ......................................................................... 129 Zbiory drzewiaste ................................................................................................. 132 Kolejki z priorytetami ............................................................................................ 138 Mapy .................................................................................................................. 139 Specjalizowane klasy zbiorów i map ....................................................................... 144 Szkielet kolekcji ........................................................................................................ 149 Widoki i opakowania............................................................................................. 152 Operacje masowe ................................................................................................ 158 Wykorzystanie biblioteki kolekcji z tradycyjnymi bibliotekami ..................................... 159 Rozbudowywanie szkieletu .................................................................................... 160 Algorytmy ................................................................................................................. 163 Sortowanie i tasowanie......................................................................................... 164 Wyszukiwanie binarne........................................................................................... 167 Proste algorytmy .................................................................................................. 168 Programowanie własnych algorytmów ..................................................................... 169 Tradycyjne kolekcje.................................................................................................... 171 Klasa Hashtable .................................................................................................. 171 Wyliczenia ........................................................................................................... 171 Zbiory właściwości ............................................................................................... 172 Stosy.................................................................................................................. 173 Zbiory bitów......................................................................................................... 173 Rozdział 3. Programowanie aplikacji sieciowych ................................................................................ 179 Połączenia z serwerem .............................................................................................. 179 Implementacja serwerów............................................................................................ 183 Obsługa wielu klientów ......................................................................................... 186 Wysyłanie poczty elektronicznej................................................................................... 189 Połączenia wykorzystujące URL ................................................................................... 193 URL i URI ............................................................................................................ 194 Zastosowanie klasy URLConnection do pobierania informacji .................................... 196 Wysyłanie danych do formularzy............................................................................. 205

4. Spis treści 5 Zaawansowane programowanie przy użyciu gniazdek sieciowych..................................... 214 Limity czasu gniazdek........................................................................................... 214 Przerywanie operacji gniazdek ............................................................................... 215 Połączenia częściowo zamknięte............................................................................ 219 Adresy internetowe............................................................................................... 220 Rozdział 4. Połączenia do baz danych: JDBC........................................................................................ 225 Architektura JDBC ..................................................................................................... 226 Typy sterowników JDBC......................................................................................... 227 Typowe zastosowania JDBC .................................................................................. 228 Język SQL................................................................................................................. 230 Instalacja JDBC......................................................................................................... 235 Podstawowe koncepcje programowania przy użyciu JDBC............................................... 235 Adresy URL baz danych......................................................................................... 236 Nawiązywanie połączenia ...................................................................................... 236 Wykonywanie poleceń języka SQL .......................................................................... 241 Zaawansowane typy języka SQL ............................................................................. 242 Zarządzanie połączeniami, poleceniami i zbiorami wyników ....................................... 245 Wypełnianie bazy danych....................................................................................... 246 Wykonywanie zapytań ................................................................................................ 249 Polecenia przygotowane........................................................................................ 250 Przewijalne i aktualizowalne zbiory wyników zapytań ...................................................... 258 Przewijalne zbiory rekordów ................................................................................... 259 Aktualizowalne zbiory rekordów.............................................................................. 262 Metadane................................................................................................................. 266 Zbiory rekordów ........................................................................................................ 275 Buforowane zbiory rekordów .................................................................................. 276 Transakcje................................................................................................................ 285 Punkty kontrolne .................................................................................................. 286 Aktualizacje wsadowe (JDBC 2) ............................................................................. 286 Zaawansowane zarządzanie połączeniami .................................................................... 289 Wprowadzenie do LDAP.............................................................................................. 290 Konfiguracja serwera LDAP.................................................................................... 291 Dostęp do informacji katalogu LDAP....................................................................... 294 Rozdział 5. Obiekty rozproszone .......................................................................................................... 305 Role klienta i serwera ................................................................................................ 306 Wywołania zdalnych metod ......................................................................................... 308 Namiastka i szeregowanie parametrów................................................................... 309 Dynamiczne ładowanie klas................................................................................... 311 Konfiguracja wywołania zdalnych metod ....................................................................... 312 Interfejsy i implementacje ..................................................................................... 312 Generowanie klasy namiastki ................................................................................ 315 Odnajdywanie obiektów serwera ............................................................................ 315 Po stronie klienta................................................................................................. 319 Przygotowanie wdrożenia....................................................................................... 324 Wdrożenie programu............................................................................................. 326 Przekazywanie parametrów zdalnym metodom .............................................................. 329 Przekazywanie lokalnych obiektów.......................................................................... 329 Przekazywanie zdalnych obiektów........................................................................... 341 Zdalne obiekty i metody equals oraz hashCode ....................................................... 343 Klonowanie zdalnych obiektów............................................................................... 344

5. 6 Java 2. Techniki zaawansowane Aktywacja obiektów serwera ....................................................................................... 344 Java IDL i CORBA ...................................................................................................... 350 Język IDL............................................................................................................. 351 Przykład aplikacji CORBA....................................................................................... 356 Implementacja serwerów CORBA ........................................................................... 365 Wywołania zdalnych metod i SOAP .............................................................................. 370 Rozdział 6. Zaawansowane mo liwości pakietu Swing....................................................................... 377 Listy ........................................................................................................................ 377 Komponent JList .................................................................................................. 378 Modele list .......................................................................................................... 384 Wstawianie i usuwanie ......................................................................................... 388 Odrysowywanie zawartości listy.............................................................................. 390 Drzewa..................................................................................................................... 395 Najprostsze drzewa .............................................................................................. 396 Przeglądanie węzłów............................................................................................. 411 Rysowanie węzłów................................................................................................ 412 Nasłuchiwanie zdarzeń w drzewach ........................................................................ 419 Własne modele drzew........................................................................................... 425 Tabele ..................................................................................................................... 433 Najprostsze tabele ............................................................................................... 433 Modele tabel ....................................................................................................... 436 Filtry sortujące ..................................................................................................... 445 Rysowanie i edytowanie zawartości komórek........................................................... 451 Operacje na wierszach i kolumnach........................................................................ 464 Wybór wierszy, kolumn i komórek........................................................................... 465 Komponenty formatujące tekst ................................................................................... 473 Wskaźniki postępu .................................................................................................... 479 Paski postępu ..................................................................................................... 480 Monitory postępu ................................................................................................. 484 Monitorowanie postępu strumieni wejścia............................................................... 489 Organizatory komponentów......................................................................................... 494 Panele dzielone ................................................................................................... 495 Panele z zakładkami............................................................................................. 499 Panele pulpitu i ramki wewnętrzne ......................................................................... 504 Rozmieszczenie kaskadowe i sąsiadujące............................................................... 507 Zgłaszanie weta do zmiany właściwości .................................................................. 510 Rozdział 7. Zaawansowane mo liwości biblioteki AWT........................................................................ 521 Potokowe tworzenie grafiki ......................................................................................... 522 Figury....................................................................................................................... 524 Wykorzystanie klas obiektów graficznych................................................................. 526 Pola......................................................................................................................... 539 Ślad pędzla .............................................................................................................. 543 Wypełnienia .............................................................................................................. 550 Przekształcenia układu współrzędnych ......................................................................... 556 Przycinanie ............................................................................................................... 565 Przezroczystość i składanie obrazów............................................................................ 569 Wskazówki operacji graficznych................................................................................... 577 Czytanie i zapisywanie plików graficznych ..................................................................... 583 Wykorzystanie obiektów zapisu i odczytu plików graficznych ...................................... 583 Odczyt i zapis plików zawierających sekwencje obrazów............................................ 585

6. Spis treści 7 Operacje na obrazach ................................................................................................ 595 Dostęp do danych obrazu...................................................................................... 595 Filtrowanie obrazów .............................................................................................. 602 Drukowanie .............................................................................................................. 610 Drukowanie grafiki................................................................................................ 611 Drukowanie wielu stron......................................................................................... 621 Podgląd wydruku .................................................................................................. 623 Usługi drukowania................................................................................................ 631 Usługi drukowania za pośrednictwem strumieni ....................................................... 637 Atrybuty drukowania ............................................................................................. 642 Schowek .................................................................................................................. 649 Klasy i interfejsy umożliwiające przekazywanie danych.............................................. 650 Przekazywanie tekstu ........................................................................................... 651 Interfejs Transferable i formaty danych ................................................................... 655 Przekazywanie obrazów za pomocą schowka ........................................................... 657 Wykorzystanie lokalnego schowka do przekazywania referencji obiektów....................... 662 Wykorzystanie schowka systemowego do przekazywania obiektów Java...................... 668 Mechanizm „przeciągnij i upuść”................................................................................. 672 Cele mechanizmu „przeciągnij i upuść” .................................................................. 674 Źródła mechanizmu „przeciągnij i upuść”................................................................ 683 Przekazywanie danych pomiędzy komponentami Swing............................................. 688 Rozdział 8. JavaBeans........................................................................................................................... 693 Dlaczego ziarnka? ..................................................................................................... 694 Proces tworzenia ziarnek JavaBeans ........................................................................... 695 Wykorzystanie ziarnek do tworzenia aplikacji ................................................................ 698 Umieszczanie ziarnek w plikach JAR ....................................................................... 699 Korzystanie z ziarnek ............................................................................................ 700 Wzorce nazw właściwości ziarnek i zdarzeń .................................................................. 705 Typy właściwości ziarnek ............................................................................................ 708 Właściwości proste .............................................................................................. 708 Właściwości indeksowane ..................................................................................... 709 Właściwości powiązane......................................................................................... 710 Właściwości ograniczone ...................................................................................... 712 Klasa informacyjna ziarnka......................................................................................... 718 Edytory właściwości ................................................................................................... 723 Implementacja edytora właściwości........................................................................ 730 Indywidualizacja ziarnka ............................................................................................. 744 Implementacja klasy indywidualizacji ...................................................................... 746 Trwałość ziarnek JavaBeans ....................................................................................... 753 Zastosowanie mechanizmu trwałości JavaBeans dla dowolnych danych...................... 758 Kompletny przykład zastosowania trwałości JavaBeans ............................................ 764 Rozdział 9. Bezpieczeństwo .................................................................................................................. 775 Ładowanie klas ......................................................................................................... 776 Implementacja własnej procedury ładującej............................................................. 779 Weryfikacja kodu maszyny wirtualnej ........................................................................... 784 Menedżery bezpieczeństwa i pozwolenia ...................................................................... 789 Bezpieczeństwo na platformie Java 2 ..................................................................... 791 Pliki polityki bezpieczeństwa.................................................................................. 794 Tworzenie własnych klas pozwoleń ......................................................................... 801 Implementacja klasy pozwoleń............................................................................... 802

7. 8 Java 2. Techniki zaawansowane Tworzenie własnych menedżerów bezpieczeństwa.................................................... 808 Uwierzytelnianie użytkowników............................................................................... 815 Moduły JAAS........................................................................................................ 820 Podpis cyfrowy .......................................................................................................... 829 Skróty wiadomości ............................................................................................... 830 Podpisywanie wiadomości..................................................................................... 835 Uwierzytelnianie wiadomości ................................................................................. 843 Certyfikaty X.509 ................................................................................................. 845 Tworzenie certyfikatów.......................................................................................... 847 Podpisywanie certyfikatów..................................................................................... 849 Podpisywanie kodu.................................................................................................... 857 Podpisywanie plików JAR....................................................................................... 857 Certyfikaty twórców oprogramowania ...................................................................... 861 Szyfrowanie .............................................................................................................. 863 Szyfrowanie symetryczne....................................................................................... 863 Strumienie szyfrujące ........................................................................................... 870 Szyfrowanie kluczem publicznym ............................................................................ 871 Rozdział 10. Internacjonalizacja ........................................................................................................... 877 Lokalizatory .............................................................................................................. 878 Formaty liczby ........................................................................................................... 883 Waluty ................................................................................................................ 889 Data i czas ............................................................................................................... 890 Porządek alfabetyczny................................................................................................ 897 Formatowanie komunikatów ....................................................................................... 905 Formatowanie z wariantami ................................................................................... 907 Pliki tekstowe i zbiory znaków ..................................................................................... 909 Internacjonalizacja a pliki źródłowe programów ........................................................ 909 Komplety zasobów .................................................................................................... 910 Lokalizacja zasobów ............................................................................................. 911 Pliki właściwości .................................................................................................. 912 Klasy kompletów zasobów..................................................................................... 913 Kompletny przykład ................................................................................................... 915 Rozdział 11. Metody macierzyste.......................................................................................................... 929 Wywołania funkcji języka C z programów w języku Java .................................................. 931 Wykorzystanie funkcji printf ................................................................................... 932 Numeryczne parametry metod i wartości zwracane........................................................ 937 Wykorzystanie funkcji printf do formatowania liczb ................................................... 937 Łańcuchy znaków jako parametry ................................................................................ 938 Wywołanie funkcji sprintf przez metodę macierzystą................................................. 942 Dostęp do składowych obiektu ................................................................................... 944 Dostęp do pól instancji......................................................................................... 944 Dostęp do pól statycznych .................................................................................... 949 Sygnatury ................................................................................................................. 949 Wywoływanie metod języka Java.................................................................................. 951 Wywoływanie metod obiektów................................................................................ 951 Wywoływanie metod statycznych ............................................................................ 952 Konstruktory........................................................................................................ 953 Alternatywne sposoby wywoływania metod .............................................................. 954 Tablice..................................................................................................................... 958 Obsługa błędów ........................................................................................................ 963

8. Spis treści 9 Interfejs programowy wywołań języka Java.................................................................... 967 Kompletny przykład: dostęp do rejestru systemu Windows ............................................. 971 Rejestr systemu Windows ..................................................................................... 971 Interfejs dostępu do rejestru na platformie Java ...................................................... 972 Implementacja dostępu do rejestru za pomocą metod macierzystych ......................... 973 Rozdział 12. Język XML ......................................................................................................................... 987 Wprowadzenie do języka XML ..................................................................................... 988 Struktura dokumentu XML..................................................................................... 990 Parsowanie dokumentów XML .................................................................................... 993 Kontrola poprawności dokumentów XML .................................................................... 1003 Definicje typów dokumentów ............................................................................... 1005 XML Schema ..................................................................................................... 1012 Praktyczny przykład ............................................................................................ 1014 Wyszukiwanie infomacji i XPath................................................................................. 1028 Przestrzenie nazw.................................................................................................... 1033 Wykorzystanie parsera SAX ...................................................................................... 1036 Tworzenie dokumentów XML..................................................................................... 1041 Przekształcenia XSL................................................................................................. 1049 Rozdział 13. Adnotacje ..........................................................................................................................1059 Umieszczanie metadanych w programach .................................................................. 1060 Przykład — adnotacje obsługi zdarzeń ....................................................................... 1061 Składnia adnotacji................................................................................................... 1066 Adnotacje standardowe............................................................................................ 1070 Adnotacje regularne ........................................................................................... 1070 Metaadnotacje................................................................................................... 1071 Narzędzie apt do przetwarzania adnotacji w kodzie źródłowym ...................................... 1074 Inżynieria kodu bajtowego ........................................................................................ 1080 Modyfikacja kodu bajtowego podczas ładowania.................................................... 1089 Skorowidz.............................................................................................................................................1093

9. 1 Wielowątkowość W tym rozdziale: n Czym są wątki? n Przerywanie wątków. n Stany wątków. n Właściwości wątków. n Synchronizacja. n Kolejki blokujące. n Kolekcje. n Interfejsy Callable i Future. n Egzekutory. n Synchronizatory. n Wątki i Swing. Czytelnik z pewnością wie, e wielozadaniowość oznacza mo liwość pracy wielu programów równocześnie. Dzięki wielozadaniowości mo emy w czasie edycji dokumentu drukować inny dokument bądź wysyłać faks. Oczywiście wtedy, gdy mamy do dyspozycji tylko maszynę o pojedynczym procesorze, uzyskujemy jedynie wra enie równoczesnego wykonywania wielu programów, poniewa system operacyjny przydziela czas procesora kolejnym zadaniom. Takie zarządzanie przydziałem procesora jest tym bardziej mo liwe, e wiele zadań absorbuje jego moc obliczeniową w znikomym stopniu. Wielozadaniowość jest realizowana na dwa sposoby: z wywłaszczaniem i bez. W pierw- szym przypadku system operacyjny samodzielnie podejmuje decyzję o przydziale procesora kolejnym zadaniom, natomiast w drugim wykonywanie zadania mo e zostać przerwane tylko wtedy, jeśli zgodzi się ono oddać sterowanie. Starsze systemy operacyjne, takie jak Windows 3.1 i Mac OS 9, pracują na zasadzie wielozadaniowości bez wywłaszczania. Wten sam sposób działają te systemy operacyjne prostych urządzeń, na przykład telefonów komórkowych. Natomiast system UNIX i jego pochodne, a tak e systemy Windows NT/XP (oraz Windows 9x w przypadku aplikacji 32-bitowych) i OS X stosują wielozadaniowość

10. 18 Java 2. Techniki zaawansowane z wywłaszczaniem. Chocia realizacja wielozadaniowości z wywłaszczaniem jest du o trudniejsza, to rozwiązanie takie jest bardziej efektywne, poniewa w przypadku wieloza- daniowości bez wywłaszczania niewłaściwie zachowująca się aplikacja mo e wstrzymać wykonywanie pozostałych zadań w systemie. Wielowątkowość rozszerza ideę wielozadaniowości w ten sposób, e ka dy z programów mo e wykonywać równocześnie wiele zadań. Zadania te nazywamy wątkami. Program, który wykonuje więcej ni jeden wątek, nazywamy wielowątkowym. Zasadnicza ró nica pomiędzy zadaniami a wątkami polega na tym, e podczas gdy ka de zadanie dysponuje własnym oddzielnym zestawem danych (zmiennych), to wątki operują na wspólnych danych. Utworzenie bądź usunięcie wątku wią e się z du o mniejszym nakładem ze strony systemu operacyjnego ni w przypadku tych samych operacji dla zadania. Podobnie komunikacja między zadaniami jest mniej efektywna ni pomiędzy wątkami. Dlatego te zdecydowana większość współczesnych systemów operacyjnych obsługuje wielowątkowość. Wielowątkowość okazuje się niesłychanie przydatna w praktyce. Przeglądarka internetowa, wykorzystując wątki, pozwala jednocześnie załadować wiele obrazów na stronie. Klient poczty elektronicznej umo liwia czytania poczty, w trakcie pobierając nowe wiadomości. Tak e Java u ywa dodatkowego wątku, aby odzyskać w tle niewykorzystywaną przez program pamięć. Po- gramy wyposa one w graficzny interfejs u ytkownika stosują osobny wątek do uzyskiwania informacji o zdarzeniach zachodzących w systemie okienkowym. W rozdziale tym poka emy, w jaki sposób wykorzystać zalety wielowątkowości w aplikacjach tworzonych w języku Java. Pakiet JDK 5.0 udostępnia wiele nowych klas i interfejsów dostarczających zaawansowanej implementacji mechanizmów wielowątkowych. W rozdziale tym omówimy nowe mo liwości JDK 5.0, a tak e klasyczne mechanizmy synchronizacji i pomo emy Ci dokonać właściwego wyboru pomiędzy nimi. Wielowątkowość nie jest prostym zagadnieniem. W rozdziale tym przedstawiamy wszystkie narzędzia, które udostępnia język Java do programowania wątków. Wyjaśniamy przy tym sposób ich wykorzystania, związane z tym ograniczenia i ilustrujemy całość prostymi, ale typowymi przykładami. W bardziej zło onych przypadkach Czytelnik powinien jednak skorzystać z bardziej specjalistycznej literatury, na przykład Concurrent Programming in Java autorstwa Douga Lea (Addison-Wesley, 1999). Czym są wątki? Zapoznajmy się najpierw z przykładowym programem, który nie u ywa wątków i w kon- sekwencji u ytkownik nie mo e wykonać za jego pomocą wielu działań naraz. Później poka emy, jak łatwo usunąć te niedogodności, wprowadzając do programu wątki. Program ten będzie animacją piłki odbijającej się od ramki okienka (patrz rysunek 1.1). Wybranie przez u ytkownika przycisku Start powoduje pojawienie się w lewym górnym rogu okienka piłki, która rozpoczyna swój ruch. Metoda obsługi zdarzenia dla przycisku Start wywołuje metodę CFF$CNN. Metoda ta zawiera pętlę, w której 1000 razy wykonywana jest metoda OQXG powodująca niewielkie przesunięcie rysunku piłki, ewentualną zmianę kierunku ruchu w przypadku odbicia od ramki i odrysowanie tła okna.

11. Rozdział 1. n Wielowątkowość 19 Rysunek 1.1. Animacja piłki odbijającej się od ramki okienka $CNN DCNN PGY $CNN RCPGNCFF DCNN HQT KPV K K 56'25 K ] DCNNOQXG RCPGNIGV$QWPFU RCPGNRCKPV RCPGNIGV)TCRJKEU 6JTGCFUNGGR '.#; _ Metoda statyczna UNGGR klasy 6JTGCF powoduje zawieszenie wykonywania pętli na okre- śloną liczbę milisekund. Wywołanie metody 6JTGCFUNGGR nie tworzy nowego wątku — metoda UNGGR jest sta- tyczną metodą klasy 6JTGCF, która powoduje wstrzymanie wykonywania aktywnego wąt- ku na określony czas. Metoda UNGGR mo e spowodować wystąpienie wyjątku +PVGTTWRVGF'ZEGRVKQP. Wyjątek ten oraz sposób jego obsługi omówimy dokładniej w dalszej części rozdziału. W obecnej wersji programu jego wystąpienie spowoduje jedynie przerwanie animacji. Animacja ruchu piłki w obecnej wersji programu absorbuje całkowicie jedyny wątek aplikacji w jej obecnej postaci. Jeśli u ytkownik zechce, zanim pętla wykona się 1000 razy, przerwać działanie programu, wybierając przycisk %NQUG, to nie przyniesie to zamierzonego efektu. Program nie mo e bowiem obsłu yć tego zdarzenia, dopóki nie zakończy animacji. Przyglądając się pełnemu tekstowi programu zamieszczonemu poniżej, zauważymy wy- wołanie ECPXCURCKPV ECPXCUIGV)TCRJKEU wewnątrz metody OQXG klasy $CNN. Rozwiązanie to może wydawać się dziwne, ponie- waż zwykle wywołujemy metodę TGRCKPV i pozwalamy AWT zająć się określeniem kon- tekstu graficznego i odrysowaniem zawartości okna. Jednak jeśli postąpimy w ten sposób także w tym programie, to odrysowanie nie będzie mogło się odbyć, ponieważ metoda CFF$CNN zmonopolizowała przetwarzanie. W następnej wersji programu, która będzie obliczać kolejne pozycji piłki w osobnym wątku, z powrotem będziemy mogli za- stosować wywołanie metody TGRCKPV.

12. 20 Java 2. Techniki zaawansowane Zachowanie obecnej wersji programu jest dalekie od doskonałości. W większości przypad- ków gdy program wykonuje czasochłonne operacje, musi istnieć mo liwość ich przerwania. Typowym przykładem są wszelkie programy czytające dane z sieci. Zawsze powinna istnieć mo liwość przerwania na przykład procesu ładowania du ego obrazka. Jeśli po obejrzeniu jego fragmentu u ytkownik stwierdzi, e nie interesuje go całość, to wybranie przycisku Stop lub Back powinno spowodować przerwanie procesu ładowania. W dalszej części rozdziału poka emy, w jaki sposób mo na zapewnić u ytkownikowi pełną kontrolę nad działaniem programu przez wykonywanie jego kluczowych fragmentów w osobnym wątku. Listing 1.1 zawiera pełen tekst źródłowy obecnej wersji programu. Listing 1.1. Bounce.java KORQTV LCXCCYV

13. KORQTV LCXCCYVGXGPV

14. KORQTV LCXCCYVIGQO

15. KORQTV LCXCWVKN

16. KORQTV LCXCZUYKPI

18. #PKOCELC QFDKLCLæEGL UKú RK MK

19. RWDNKE ENCUU $QWPEG ] RWDNKE UVCVKE XQKF OCKP 5VTKPI=? CTIU ] ,(TCOG HTCOG PGY $QWPEG(TCOG HTCOGUGVGHCWNV%NQUG1RGTCVKQP ,(TCOG':+6A10A%.15' HTCOGUGV8KUKDNG VTWG _ _

21. 2K MC RQTWUCLæEC UKú K QFDKLCLæEC QF MTCYúFK MQORQPGPVW

22. ENCUU $CNN ]

24. 2TGUWYC RK Mú FQ PCUVúRPGL RQ[ELK OKGPKCLæE MKGTWPGM TWEJW LG NK PCVTCHK PC MTCYúF

25. RWDNKE XQKF OQXG 4GEVCPING DQWPFU ] Z FZ [ F[ KH Z DQWPFUIGV/KP: ] Z DQWPFUIGV/KP: FZ FZ _ KH Z :5+' DQWPFUIGV/CZ: ] Z DQWPFUIGV/CZ: :5+' FZ FZ _

26. Rozdział 1. n Wielowątkowość 21 KH [ DQWPFUIGV/KP; ] [ DQWPFUIGV/KP; F[ F[ _ KH [ ;5+' DQWPFUIGV/CZ; ] [ DQWPFUIGV/CZ; ;5+' F[ F[ _ _

28. 6YQT[ MUVC V RK MK FNC DKG æEGL RQ[ELK

29. RWDNKE 'NNKRUG IGV5JCRG ] TGVWTP PGY 'NNKRUGQWDNG Z [ :5+' ;5+' _ RTKXCVG UVCVKE HKPCN KPV :5+' RTKXCVG UVCVKE HKPCN KPV ;5+' RTKXCVG FQWDNG Z RTKXCVG FQWDNG [ RTKXCVG FQWDNG FZ RTKXCVG FQWDNG F[ _

31. 2CPGN T[UWLæE[ RK MK

32. ENCUU $CNN2CPGN GZVGPFU ,2CPGN ]

34. QFCLG RK Mú FQ RCPGNW RCTCO D FQFCYCPC RK MC

35. RWDNKE XQKF CFF $CNN D ] DCNNUCFF D _ RWDNKE XQKF RCKPV%QORQPGPV )TCRJKEU I ] UWRGTRCKPV%QORQPGPV I )TCRJKEU I )TCRJKEU I HQT $CNN D DCNNU ] IHKNN DIGV5JCRG _ _ RTKXCVG #TTC[.KUV$CNN DCNNU PGY #TTC[.KUV$CNN _

37. 4COMC CYKGTCLæEC V Q K RT[EKUMK

38. 22 Java 2. Techniki zaawansowane

39. ENCUU $QWPEG(TCOG GZVGPFU ,(TCOG ]

41. -QPUVTWWLG TCOMú CYKGTCLæEæ RCPGN Y MVÎTGL CPKOQYCPC DúFKG RK MC K RQMCCPG RT[EKUMK 5VCTV K %NQUG

42. RWDNKE $QWPEG(TCOG ] UGV5KG '(#7.6A9+6* '(#7.6A*'+)*6 UGV6KVNG $QWPEG RCPGN PGY $CNN2CPGN CFF RCPGN $QTFGT.C[QWV%'06'4 ,2CPGN DWVVQP2CPGN PGY ,2CPGN CFF$WVVQP DWVVQP2CPGN 5VCTV PGY #EVKQP.KUVGPGT ] RWDNKE XQKF CEVKQP2GTHQTOGF #EVKQP'XGPV GXGPV ] CFF$CNN _ _ CFF$WVVQP DWVVQP2CPGN %NQUG PGY #EVKQP.KUVGPGT ] RWDNKE XQKF CEVKQP2GTHQTOGF #EVKQP'XGPV GXGPV ] 5[UVGOGZKV _ _ CFF DWVVQP2CPGN $QTFGT.C[QWV5176* _

44. QFCLG RT[EKUM FQ MQPVGPGTC RCTCO E MQPVGPGT RCTCO VKVNG PCYC RT[EKUMW RCTCO NKUVGPGT QDKGMV PCU WEJWLæE[ RT[EKUMW

45. RWDNKE XQKF CFF$WVVQP %QPVCKPGT E 5VTKPI VKVNG #EVKQP.KUVGPGT NKUVGPGT ] ,$WVVQP DWVVQP PGY ,$WVVQP VKVNG ECFF DWVVQP DWVVQPCFF#EVKQP.KUVGPGT NKUVGPGT _

47. QFCLG RK Mú FQ RCPGNW 4[UWLG RK Mú K CPKOWLG Læ TC[

48. RWDNKE XQKF CFF$CNN ] VT[

49. Rozdział 1. n Wielowątkowość 23 ] $CNN DCNN PGY $CNN RCPGNCFF DCNN HQT KPV K K 56'25 K ] DCNNOQXG RCPGNIGV$QWPFU RCPGNRCKPV RCPGNIGV)TCRJKEU 6JTGCFUNGGR '.#; _ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP G ] _ _ RTKXCVG $CNN2CPGN RCPGN RWDNKE UVCVKE HKPCN KPV '(#7.6A9+6* RWDNKE UVCVKE HKPCN KPV '(#7.6A*'+)*6 RWDNKE UVCVKE HKPCN KPV 56'25 RWDNKE UVCVKE HKPCN KPV '.#; _ LCXCNCPI6JTGCF n UVCVKE XQKF UNGGR NQPI OKNNKU zawiesza wykonanie wątku na określoną liczbę milisekund. Parametry: OKNNKU liczba milisekund zawieszenia wątku Zastosowanie wątków Program animacji piłki mo e lepiej odpowiadać na akcje u ytkownika, jeśli kod odpowie- dzialny za animację umieścimy w osobnym wątku. Rozwiązanie takie pozwoli nam nawet animować wiele piłek. Animacja ka dej z nich odbywać będzie się w osobnym wątku. Równolegle z wątkami animacji działać będzie równie wątek obsługi zdarzeń AWT zaj- mujący się obsługą zdarzeń związanych z interfejsem u ytkownika. Poniewa wszystkie wątki mają równą szansę wykonania, to główny wątek programu mo e teraz uzyskać info- mację o wybraniu przez u ytkownika przycisku Close i odpowiednio zareagować na to zda- rzenie. A oto prosty sposób na uruchomienie zadania w osobnym wątku: 1. Kod realizujący zadanie umieszczamy wewnątrz metody TWP klasy implementującej interfejs 4WPPCDNG. Interfejs ten jest bardzo prosty i posiada tylko jedną metodę: RWDNKE KPVGTHCEG 4WPPCDNG ] XQKF TWP _ Klasę implementującą ten interfejs tworzymy w następujący sposób:

50. 24 Java 2. Techniki zaawansowane ENCUU /[4WPPCDNG KORNGOGPVU 4WPPCDNG ] RWDNKE XQKF TWP ] MQF CFCPKC _ _ 2. Następnie tworzymy obiekt naszej klasy: 4WPPCDNG T PGY /[4WPPCDNG 3. Tworzymy obiekt 6JTGCF na podstawie obiektu 4WPPCDNG: 6JTGCF V PGY 6JTGCF T 4. Uruchamiamy wątek: VUVCTV Aby kod animacji piłki wykonywany był we własnym wątku, wystarczy umieścić go we- wnątrz metody TWP klasy $CNN4WPPCDNG: ENCUU $CNN4WPPCDNG KORNGOGPVU 4WPPCDNG ] RWDNKE XQKF TWP ] VT[ ] HQT KPV K K 56'25 K ] DCNNOQXG EQORQPGPVIGV$QWPFU EQORQPGPVTGRCKPV 6JTGCFUNGGR '.#; _ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP G ] _ _ _ Powy szy fragment kodu zawiera tak e obsługę wyjątku +PVGTTWRVGF'ZEGRVKQP, którego wystąpienie mo e spowodować metoda UNGGR. Wyjątek ten omówimy w następnym punk- cie. Typowo, aby zakończyć wykonywanie wątku, przerywa się jego działanie. Zgodnie z tą zasadą wystąpienie wyjątku +PVGTTWRVGF'ZEGRVKQP spowoduje zakończenie wykonywania naszej metody TWP. Za ka dym razem, gdy u ytkownik wybierze przycisk Start, metoda CFF$CNN uruchamia nowy wątek (patrz rysunek 1.2): $CNN D PGY $CNN RCPGNCFF D 4WPPCDNG T PGY $CNN4WPPCDNG D RCPGN 6JTGCF V PGY 6JTGCF T VUVCTV

51. Rozdział 1. n Wielowątkowość 25 Rysunek 1.2. Animacja wielowątkowa I to wszystko! W ten sposób dowiedziałeś się, w jaki sposób uruchamiać równolegle dzia- łające wątki. Pozostała część tego rozdziału poświęcona jest interakcjom pomiędzy wątkami. Wątek możemy również zdefiniować, tworząc klasę pochodną klasy 6JTGCF: ENCUU /[6JTGCF GZVGPFU 6JTGCF ] RWDNKE XQKF TWP ] MQF CFCPKC _ _ Następnie tworzymy obiekt tej klasy pochodnej i wywołujemy jego metodę UVCTV. Roz- wiązanie takie nie jest jednak zalecane. Należy dążyć do oddzielenia wykonywanego zadania od mechanizmu jego wykonywania. W sytuacji, gdy musimy wykonać dużą licz- bę zadań, tworzenie wątku dla każdego z nich jest zbyt kosztowne i lepiej jest wykorzy- stać pulę wątków (patrz strona 83.). Nie należy wywoływać bezpośrednio metody TWP — zostanie ona wywołana przez me- todę UVCTV, w momencie gdy wątek jest gotowy do rozpoczęcia działania. Bezpośred- nie wywołanie metody TWP spowoduje jej wykonanie w bieżącym wątku zamiast utwo- rzenia nowego. Listing 1.2 zawiera kompletny kod animacji wielowątkowej. Listing 1.2. BounceThread.java KORQTV LCXCCYV

52. KORQTV LCXCCYVGXGPV

53. KORQTV LCXCCYVIGQO

54. KORQTV LCXCWVKN

55. KORQTV LCXCZUYKPI

56. 26 Java 2. Techniki zaawansowane

59. RWDNKE ENCUU $QWPEG6JTGCF ] RWDNKE UVCVKE XQKF OCKP 5VTKPI=? CTIU ] ,(TCOG HTCOG PGY $QWPEG(TCOG HTCOGUGVGHCWNV%NQUG1RGTCVKQP ,(TCOG':+6A10A%.15' HTCOGUGV8KUKDNG VTWG _ _

62. ENCUU $CNN4WPPCDNG KORNGOGPVU 4WPPCDNG ]

64. -QPUVTWMVQT C$CNN RK MC C2CPGN MQORQPGPV Y MVÎT[O DúFKG CPKOQYCPC

65. RWDNKE $CNN4WPPCDNG $CNN C$CNN %QORQPGPV C%QORQPGPV ] DCNN C$CNN EQORQPGPV C%QORQPGPV _ RWDNKE XQKF TWP ] VT[ ] HQT KPV K K 56'25 K ] DCNNOQXG EQORQPGPVIGV$QWPFU EQORQPGPVTGRCKPV 6JTGCFUNGGR '.#; _ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP G ] _ _ RTKXCVG $CNN DCNN RTKXCVG %QORQPGPV EQORQPGPV RWDNKE UVCVKE HKPCN KPV 56'25 RWDNKE UVCVKE HKPCN KPV '.#; _

67. 2K MC RQTWUCLæEC UKú K QFDKLCLæEC QF MTCYúFK MQORQPGPVW

68. ENCUU $CNN ]

69. Rozdział 1. n Wielowątkowość 27

71. 2TGUWYC RK Mú FQ PCUVúRPGL RQ[ELK OKGPKCLæE MKGTWPGM TWEJW LG NK PCVTCHK PC MTCYúF

72. RWDNKE XQKF OQXG 4GEVCPING DQWPFU ] Z FZ [ F[ KH Z DQWPFUIGV/KP: ] Z DQWPFUIGV/KP: FZ FZ _ KH Z :5+' DQWPFUIGV/CZ: ] Z DQWPFUIGV/CZ: :5+' FZ FZ _ KH [ DQWPFUIGV/KP; ] [ DQWPFUIGV/KP; F[ F[ _ KH [ ;5+' DQWPFUIGV/CZ; ] [ DQWPFUIGV/CZ; ;5+' F[ F[ _ _

74. 6YQT[ MUVC V RK MK FNC DKG æEGL RQ[ELK

75. RWDNKE 'NNKRUG IGV5JCRG ] TGVWTP PGY 'NNKRUGQWDNG Z [ :5+' ;5+' _ RTKXCVG UVCVKE HKPCN KPV :5+' RTKXCVG UVCVKE HKPCN KPV ;5+' RTKXCVG FQWDNG Z RTKXCVG FQWDNG [ RTKXCVG FQWDNG FZ RTKXCVG FQWDNG F[ _

77. 2CPGN T[UWLæE[ RK Mú

78. ENCUU $CNN2CPGN GZVGPFU ,2CPGN ]

80. QFCLG RK Mú FQ RCPGNW RCTCO D FQFCYCPC RK MC

81. RWDNKE XQKF CFF $CNN D ] DCNNUCFF D

82. 28 Java 2. Techniki zaawansowane _ RWDNKE XQKF RCKPV%QORQPGPV )TCRJKEU I ] UWRGTRCKPV%QORQPGPV I )TCRJKEU I )TCRJKEU I HQT $CNN D DCNNU ] IHKNN DIGV5JCRG _ _ RTKXCVG #TTC[.KUV$CNN DCNNU PGY #TTC[.KUV$CNN _

84. 4COMC CYKGTCLæEC RCPGN K RT[EKUMK

85. ENCUU $QWPEG(TCOG GZVGPFU ,(TCOG ]

87. -QPUVTWWLG TCOMú RCPGNGO Y MVÎTGL CPKOQYCPC DúFKG RK MC K WOKGUEQPG RT[EKUMK 5VCTV K %NQUG

88. RWDNKE $QWPEG(TCOG ] UGV5KG '(#7.6A9+6* '(#7.6A*'+)*6 UGV6KVNG $QWPEG6JTGCF RCPGN PGY $CNN2CPGN CFF RCPGN $QTFGT.C[QWV%'06'4 ,2CPGN DWVVQP2CPGN PGY ,2CPGN CFF$WVVQP DWVVQP2CPGN 5VCTV PGY #EVKQP.KUVGPGT ] RWDNKE XQKF CEVKQP2GTHQTOGF #EVKQP'XGPV GXGPV ] CFF$CNN _ _ CFF$WVVQP DWVVQP2CPGN %NQUG PGY #EVKQP.KUVGPGT ] RWDNKE XQKF CEVKQP2GTHQTOGF #EVKQP'XGPV GXGPV ] 5[UVGOGZKV _ _ CFF DWVVQP2CPGN $QTFGT.C[QWV5176* _

90. QFCLG RT[EKUM FQ MQPVGPGTC RCTCO E MQPVGPGT RCTCO VKVNG PCYC RT[EKUMW RCTCO NKUVGPGT QDKGMV PCU WEJWLæE[ RT[EKUMW

91. Rozdział 1. n Wielowątkowość 29 RWDNKE XQKF CFF$WVVQP %QPVCKPGT E 5VTKPI VKVNG #EVKQP.KUVGPGT NKUVGPGT ] ,$WVVQP DWVVQP PGY ,$WVVQP VKVNG ECFF DWVVQP DWVVQPCFF#EVKQP.KUVGPGT NKUVGPGT _

93. 6YQT[ RK Mú K WTWEJCOKC PQY[ YæVGM LGL CPKOCELK

94. RWDNKE XQKF CFF$CNN ] $CNN D PGY $CNN RCPGNCFF D 4WPPCDNG T PGY $CNN4WPPCDNG D RCPGN 6JTGCF V PGY 6JTGCF T VUVCTV _ RTKXCVG $CNN2CPGN RCPGN RWDNKE UVCVKE HKPCN KPV '(#7.6A9+6* RWDNKE UVCVKE HKPCN KPV '(#7.6A*'+)*6 RWDNKE UVCVKE HKPCN KPV 56'25 RWDNKE UVCVKE HKPCN KPV '.#; _ LCXCNCPI6JTGCF n 6JTGCF 4WPPCDNG VCTIGV tworzy nowy wątek, który wykonywać będzie metodę run obiektu VCTIGV. n XQKF UVCTV uruchamia ten wątek i powoduje wywołanie metody TWP. Metoda UVCTV oddaje natychmiast sterowanie do metody, która ją wywołała, a nowy wątek wykonywany jest równolegle. n XQKF TWP wywołuje metodę TWP odpowiedniego obiektu implementującego interfejs 4WPPCDNG. LCXCNCPI4WPPCDNG n XQKF TWP — tę metodę nale y zastąpić własną wersją zawierającą kod, który ma być wykonywany w nowym wątku. Przerywanie wątków Wykonanie wątku kończy się w momencie, gdy metoda TWP zwraca sterowanie. (W pierw- szej wersji języka Java istniała tak e metoda UVQR, za pomocą której jeden wątek mógł za- kończyć wykonywanie innego. Obecnie metoda ta nie jest stosowana, a przyczyny tego omówimy w dalszej części rozdziału).

95. 30 Java 2. Techniki zaawansowane Obecnie nie istnieje więc sposób, aby wymusić zakończenie wątku. Mo na jednak za ądać zakończenia wątku za pomocą metody KPVGTTWRV. Wywołanie metody KPVGTTWRV powoduje nadanie wątkowi statusu przerwania. Status ten jest reprezentowany za pomocą znacznika logicznego. Wartość tego znacznika powinna być okresowo sprawdzana przez wątek. Aby sprawdzić status przerwania wątku, nale y najpierw wywołać metodę statyczną 6JTG CFEWTTGPV6JTGCF, aby uzyskać bie ący wątek, a następnie wywołać metodę KU+PVGTTWRVGF sprawdzającą jego status: YJKNG 6JTGCFEWTTGPV6JTGCF KU+PVGTTWRVGF Uæ FKC CPKC FQ Y[MQPCPKC ] Y[MQPCL VG FKC CPKC _ Jednak wątek, którego wykonywanie zostało zablokowane, nie mo e sprawdzić własnego statusu przerwania. I właśnie w takim przypadku pomocny jest wyjątek +PVGTTWRVGF'ZEGR VKQP. Jeśli metoda KPVGTTWRV zostanie wywołana dla wątku, którego wykonanie jest zablokowane, to blokująca go metoda UNGGR lub YCKV zostanie przerwana i pojawi się wyjątek +PVGTTWRVGF'ZEGRVKQP. Środowisko języka Java nie wymaga wcale, aby wątek przerwany w taki sposób zakończył swoje wykonywanie. Przerwanie wątku sygnalizuje jedynie pojawienie się pewnego ąda- nia. Przerwany wątek sam decyduje, w jaki sposób zareagować na takie ądanie. Wykona- nie niektórych wątków w programie mo e być na tyle wa ne, e po prostu zignorują one wyjątek i kontynuować będą swoje działanie. Najczęściej jednak wątek zinterpretuje wyją- tek jako ądanie zakończenia wykonywania. Metoda TWP takiego wątku wygląda wtedy na- stępująco: RWDNKE XQKF TWP ] VT[ ] YJKNG 6JTGCFEWTTGPV6JTGCF KU+PVGTTWRVGF Uæ FKC CPKC FQ Y[MQPCPKC ] Y[MQPCL VG FKC CPKC _ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP GZEGRVKQP ] YæVGM RTGTYCP[ Y VTCMEKG OGVQF[ UNGGR NWD YCKV _ HKPCNN[ ] YæVGM URTæVC RQ UQDKG LG NK VQ MQPKGEPG _ CMQ EGPKG Y[MQP[YCPKC OGVQF[ TWP K V[O UCO[O YæVMW _ Sprawdzenie statusu przerwania wątku za pomocą metody KU+PVGTTWRVGF nie jest konieczne, gdy metoda UNGGR wywoływana jest po ka dej iteracji przetwarzania. Gdy wątek posiada status przerwania, to wywołanie metody UNGGR spowoduje wystąpienie wyjątku +PVGTTWR

96. Rozdział 1. n Wielowątkowość 31 VGF'ZEGRVKQP. Dlatego te , gdy metoda UNGGR wywoływana jest w pętli, to nie musimy sprawdzać statusu przerwania wątku. Wystarczy jedynie zająć się obsługą wyjątku +PVGT TWRVGF'ZEGRVKQP. Metoda TWP posiada wtedy następującą postać: RWDNKE XQKF TWP ] VT[ ] YJKNG Uæ FKC CPKC FQ Y[MQPCPKC ] Y[MQPCL VG FKC CPKC 6JTGCFUNGGR FGNC[ _ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP GZEGRVKQP ] YæVGM RTGTYCP[ Y VTCMEKG OGVQF[ UNGGR NWD YCKV _ HKPCNN[ ] YæVGM URTæVC RQ UQDKG LG NK VQ MQPKGEPG _ CMQ EGPKG Y[MQP[YCPKC OGVQF[ TWP K V[O UCO[O YæVMW _ Wygenerowanie wyjątku +PVGTTWRVGF'ZEGRVKQP przez metodę UNGGR kasuje status przerwania wątku. Istnieją dwie podobne metody, KPVGTTWRVGF oraz KU+PVGTTWRVGF. Metoda KPVGTTWRVGF jest statyczną metodą, która sprawdza, czy bieżący wątek został przerwany. Dodatko- wo wywołanie metody KPVGTTWRVGF kasuje status przerwania wątku. Natomiast metoda KU+PVGTTWRVGF wywoływana jest dla konkretnej instancji wątku i umożliwia sprawdzenie statusu przerwania dowolnego wątku. Jej wywołanie nie zmienia tego statusu. Często mo na spotkać fragmenty kodu, w których obsługa wystąpienia wyjątku +PVGTTWR VGF'ZEGRVKQP jest pominięta, co widać poni ej: VT[ ] UNGGR FGNC[ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP GZEGRVKQP ]_ .' Nie wolno pisać programów w ten sposób! Jeśli nie wiemy, jak obsłu yć wyjątek w klauzuli ECVEJ, to zawsze mamy jeszcze dwie inne mo liwości: n W klauzuli ECVEJ wywołać 6JTGCFEWTTGPV6JTGCF KPVGTTWRV w celu nadania wątkowi statusu przerwania, który mo e być sprawdzony przez kod wywołujący. XQKF O[5WD6CUM ] VT[ ] UNGGR FGNC[ _ ECVEJ +PVGTTWRVGF'ZEGRVKQP G ] 6JTGCFEWTTGPV6JTGCF KPVGTTWRV _ _

97. 32 Java 2. Techniki zaawansowane n Lepsze rozwiązanie polega na zadeklarowaniu metody jako VJTQYU +PVGTTWRVGF'ZEGRVKQP i pominięciu bloku VT[. Dzięki temu kod wywołujący metodę (lub w końcu sama metoda TWP) będzie mógł obsłu yć wyjątek. XQKF O[5WD6CUM VJTQYU +PVGTTWRVGF'ZEGRVKQP ] UNGGR FGNC[ _ LCXCNCPI6JTGCF n XQKF KPVGTTWRV wysyła ądanie przerwania wątku. Status przerwania wątku przyjmuje wtedy wartość VTWG. Jeśli wykonanie wątku jest zablokowane przez wywołanie metody UNGGR lub YCKV, to występuje wyjątek +PVGTTWRVGF'ZEGRVKQP. n UVCVKE DQQNGCP KPVGTTWRVGF sprawdza, czy bie ący wątek (czyli ten, który ją wywołał) otrzymał ądanie przerwania. Zwróćmy uwagę, e jest to metoda statyczna. Jej wywołanie posiada efekt uboczny w postaci skasowania statusu przerwania bie ącego wątku. n DQQNGCP KU+PVGTTWRVGF sprawdza, czy wątek otrzymał ądanie przerwania. Nie powoduje skasowania statusu przerwania wątku w przeciwieństwie do metody KPVGTTWRVGF. n UVCVKE 6JTGCF EWTTGPV6JTGCF zwraca obiekt klasy 6JTGCF reprezentujący aktualnie wykonywany wątek. Stany wątków Wątki mogą znajdować się w jednym z czterech stanów: n nowym, n wykonywalnym, n zablokowanym, n martwym. Ka dy z wymienionych stanów omówiomy w kolejnych podrozdziałach. Nowe wątki Kiedy tworzymy wątek za pomocą operatora PGY — na przykład PGY $CNN — nie jest on jeszcze wykonywany. Znajduje się wtedy w stanie nowy i kod w nim zawarty nie jest wykonywany. Zanim zostanie uruchomiony, system musi wykonać jeszcze pewne operacje.

98. Rozdział 1. n Wielowątkowość 33 Wątki wykonywalne Po wywołaniu metody UVCTV wątek jest wykonywalny. Wykonywalny wątek nie musi być od razu wykonywany. Przydział procesora zale y bowiem od systemu operacyjnego. Kiedy zostanie przydzielony, mówimy, e wątek jest wykonywany. (Dokumentacja języka Java nie przewiduje w tym przypadku oddzielnego stanu wątku, wątek wykonywany znajduje się nadal w stanie wykonywalnym). Wątek nie powinien być wykonywany w sposób ciągły. Po ądane jest, aby ka dy z wątków cyklicznie zawieszał swoje wykonanie, dając tym samym szansę innym wątkom. Szczegóły szeregowania wątków zale ą tak e od systemu operacyjnego. Systemy stosujące szeregowanie z wydziedziczaniem udostępniają ka demu wątkowi wykonywalnemu przedział czasu, w którym mo e on wykonywać swoje zadania. Gdy przedział ten zakończy się, system operacyjny wywłaszcza wątek, dając okazję wykonania kolejnemu wątkowi (patrz rysunek 1.4). Wy- bierając ten wątek, system operacyjny bierze pod uwagę priorytety wątków (patrz strona 36.). Wszystkie współczesne systemy operacyjne stacji roboczych i serwerów stosują szeregowanie z wywłaszczaniem, natomiast proste urządzenia, takie jak na przykład telefony ko- mórkowe, mogą u ywać szeregowania kooperacyjnego. W takim przypadku wątek prze- staje być wykonywany dopiero wtedy, gdy sam wywoła odpowiednią metodę w rodzaju UNGGR czy [KGNF. W systemach posiadających wiele procesorów ka dy procesor mo e wykonywać inny wą- tek. Mamy wtedy sytuację, w której wątki rzeczywiście wykonywane są równolegle. Jeśli jednak wątków jest więcej ni procesorów, to szeregowanie wątków znowu musi odbywać się z podziałem czasu. Nale y pamiętać, e wątek będący w stanie wykonywalnym w danym momencie mo e być wykonywany lub nie (dlatego stan ten określamy jako wykonywalny, a nie wykonywany). Wątki zablokowane Wątek znajduje się w stanie zablokowanym, w przypadku gdy zaszła jedna z poni szych sytuacji: n Wywołana została metoda UNGGR danego wątku. n Wykonanie wątku zostało zablokowane przez operację wejścia-wyjścia, która zwróci sterowanie do wątku, gdy zakończy swoje działanie. n Wątek próbuje zablokować dostęp do obiektu, który został ju zablokowany przez inny wątek. Blokady obiektów omówimy w dalszej części tego rozdziału, na stronie 46. n Wątek oczekuje na spełnienie pewnego warunku — patrz strona 49. n Wywołana została metoda UWURGPF danego wątku. Nie jest ona obecnie stosowana i nie powinna być u ywana w programach. Przyczynę tego stanu rzeczy omówimy w dalszej części tego rozdziału.

99. 34 Java 2. Techniki zaawansowane Rysunek 1.3 pokazuje diagram stanów wątku. Kiedy wątek zostaje zablokowany lub zakoń- czony, rozpoczyna się wykonywanie kolejnego wątku. Kiedy zablokowany wątek zostaje po- nownie aktywowany (poniewa upłynął okres czasu, na który zawiesił on swoje wykonywanie bądź zakończyła się blokująca go operacja wejścia-wyjścia), program szeregujący wątki sprawdza, czy posiada on priorytet wy szy od aktualnie wykonywanego wątku. Jeśli tak, to wywłaszcza bie ący wątek i rozpoczyna wykonywanie reaktywowanego wątku. Rysunek 1.3. Diagram stanów wątku Wątek mo e powrócić ze stanu zablokowanego do stanu wykonywalnego, przebywając na diagramie jedną z następujących dróg. 1. Jeśli wątek zawiesił wykonywanie wywołując metodę UNGGR, musi upłynąć określona liczba milisekund. 2. Jeśli wątek został zablokowany przez operację wejścia-wyjścia, to musi ona się zakończyć. 3. Jeśli wątek zamierza uzyskać blokadę obiektu posiadaną przez inny wątek, to wątek ten musi zrzec się blokady obiektu. (Mo liwe jest równie oczekiwanie na zwolnienie blokady z określonym limitem czasu. Wtedy wątek zostaje odblokowany po jego upływie). 4. Jeśli wątek oczekuje na spełnienie pewnego warunku, to jego zajście musi zostać zasygnalizowane przez inny wątek. (Mo liwe jest równie oczekiwanie na spełnienie warunku z określonym limitem czasu. Wtedy wątek zostaje odblokowany po jego upływie). 5. Jeśli wątek zawiesił swoje wykonywanie, to inny wątek musi wywołać jego metodę TGUWOG. Stosowanie metod UWURGPF i TGUWOG nie jest jednak zalecane.

100. Rozdział 1. n Wielowątkowość 35 Zablokowany wątek mo e powrócić do stanu wykonywalnego jedynie tą samą drogą, na której został zablokowany. W szczególności nie wystarczy wywołanie metody TGUWOG, aby odblokować wątek. Dla odblokowania operacji wejścia i wyjścia należy stosować mechanizm kanałów ofe- rowany przez nową bibliotekę wejścia i wyjścia. Gdy inny wątek zamyka kanał, to zablokowany wątek powraca do stanu wykonywalnego, a blokująca operacja generuje wy- jątek %NQUGF%JCPPGN'ZEGRVKQP. Wątki martwe Wątek mo e być martwy gdy zaistnieje jeden z dwóch powodów. n Zakończy się wykonywanie metody TWP w prawidłowy sposób. n Wykonanie metody TWP zostanie przerwane ze względu na wystąpienie wątku, którego metoda ta nie obsługuje. W szczególności mo liwe jest „zabicie” wątku przez wywołanie metody UVQR. Powoduje ona wystąpienie błędu 6JTGCFGCVJ, co kończy wykonywanie wątku. Metoda ta niesie ze sobą pewne zagro enia (omówimy je w dalszej części rozdziału) i nie powinna być stosowana w programach. Aby uzyskać informację o tym, czy dany wątek „ yje” (czyli jest wykonywalny lub zablokowany), stosujemy metodę KU#NKXG. Zwraca ona wartość logiczną VTWG, gdy wątek jest wykonywalny lub zablokowany albo wartość HCNUG, jeśli jest nowy bądź martwy. Nie można uzyskać informacji o tym, czy dany wątek jest wykonywalny, czy też zablokowany, a także informacji o tym, czy jest w danej chwili wykonywany. Podobnie nie można rozróżnić stanu wątku, w którym nie jest on jeszcze wykonywalny, od stanu, w którym jest już martwy. LCXCNCPI6JTGCF n DQQNGCP KU#NKXG zwraca wartość VTWG, jeśli wątek ju rozpoczął działanie i jeszcze się nie zakończył. n XQKF UVQR kończy wykonanie wątku. U ycie tej metody nie jest zalecane. n XQKF UWURGPF zawiesza wykonanie wątku. U ycie tej metody nie jest zalecane. n XQKF TGUWOG podejmuje wykonanie wątku zawieszonego metodą UWURGPF. U ycie obu metod nie jest zalecane. n XQKF LQKP oczekuje zakończenia działania określonego wątku. n XQKF LQKP NQPI OKNNKU oczekuje zakończenia działania określonego wątku lub upływu OKNNKU milisekund.

101. 36 Java 2. Techniki zaawansowane Właściwości wątków W kolejnych punktach omówione zostaną inne właściwości wątków: priorytety, wątki- demony, grupy wątków i domyślne procedury obsługi wyjątków. Priorytety wątków W języku Java z ka dym wątkiem związany jest określony priorytet. Domyślnie wątek dzie- dziczy priorytet po swoim wątku nadrzędnym, czyli wątku, który go utworzył. Mo na go jednak zmniejszyć lub zwiększyć, stosując metodę UGV2TKQTKV[. Za jej pomocą mo na prioryte- towi nadać dowolną wartość z przedziału od /+0A24+14+6; (zdefiniowane jako 1 w klasie 6JTGCF) do /#:A24+14+6; (zdefiniowane jako 10). Priorytet 014/A24+14+6; posiada wartość 5. Gdy program szeregowania wątków musi wybrać nowy wątek, zawsze wybiera wątek wykonywalny o najwy szym priorytecie. Nale y zaznaczyć, e wszelkie zasady działania zwią- zane z priorytetami wątków są w znacznym stopniu zale ne od konkretnego systemu operacyjnego. Jeśli maszyna wirtualna języka Java wykorzystuje zarządzanie wątkami danej platformy, to musi dokonać odwzorowania priorytetów wątków zdefiniowanych w języku Java na poziomy priorytetów tej platformy (których mo e być mniej lub więcej ni wartości priorytetów w języku Java). Na przykład w systemie Windows NT/XP istnieje siedem poziomów priorytetów, mniej ni definiuje to Java. Niezale nie więc od sposobu odwzorowanie priorytetów zdarzać się będzie, e wątki, które mają ró ny priorytet w języku Java, będą posiadać w rzeczywistości ten sam priorytet z punktu widzenia systemu operacyjnego. W przypadku maszyny wirtualnej Java firmy Sun dla systemu Linux informacja o priorytetach wątków jest w ogóle ignorowana. Z tego powodu nale y traktować priorytety wątków jedynie jako rodzaj wskazówki dla programu szeregującego. W adnym wypadku nie nale y tworzyć programów, których po- prawne działanie zale y od poziomów priorytetów. Jeśli zamierzasz używać priorytetów wątków, to powinieneś wiedzieć o błędzie popeł- nianym często przez początkujących. Jeśli w programie istnieje kilka wątków o wyso- kim priorytecie, które rzadko znajdują się w stanie zablokowanym, to mogą one unie- możliwić wykonywanie wątków o niskim priorytecie. Program szeregujący wątki zawsze wybiera najpierw spośród wątków o wyższym priorytecie, nawet jeśli w ten sposób wątki o niższym priorytecie nie są nigdy wykonywane. LCXCNCPI6JTGCF n XQKF UGV2TKQTKV[ KPV PGY2TKQTKV[ określa priorytet wątku. Wartość priorytetu musi znajdować się w przedziale od 6JTGCF/+0A24+14+6; do 6JTGCF/#:A24+14+6;. Priorytet zwykłego wątku posiada wartość 6JTGCF014/A24+14+6;. n UVCVKE KPV /+0A24+14+6; minimalna wartość priorytetu wątku (wynosi 1). n UVCVKE KPV 014/A24+14+6; domyślna wartość priorytetu wątku (wynosi 5).

102. Rozdział 1. n Wielowątkowość 37 n UVCVKE KPV /#:A24+14+6; maksymalna wartość priorytetu wątku (wynosi 10). n UVCVKE XQKF [KGNF zawiesza wykonanie bie ącego wątku. Kolejnym wykonywanym wątkiem będzie wątek wykonywalny, o co najmniej takim samym priorytecie jak wątek zawieszony. Metoda statyczna. Wątki-demony Wątek staje się wątkiem-demonem przez wywołanie VUGVCGOQP VTWG Wątek-demon nie ma w sobie nic demonicznego. Jest to po prostu wątek, którego jedynym zadaniem jest słu enie innym wątkom. Przykładem wątków-demonów mogą być wątki ze- gara, które dostarczają innym wątkom informacji o upływie czasu. Jeśli dla danego programu pozostaje jedynie wątek-demon, to program kończy swoje działania. LCXCNCPI6JTGCF n XQKF UGVCGOQP DQQNGCP KUCGOQP oznacza dany wątek jako wątek-demon bądź wątek u ytkownika. Jeśli aktywne są tylko wątki-demony, to program kończy swoje działanie. Metoda ta musi być wywołana przed wystartowaniem wątku. Grupy wątków Niektóre programy wykonują wiele wątków. Przydatna wtedy okazuje się mo liwość kate- goryzacji na podstawie ich funkcji. Jako przykład weźmy przeglądarkę internetową. Jeśli wiele wątków zajmuje się ładowaniem ró nych obrazków zamieszczonych na danej stronie, a u ytkownik wybierze przycisk Stop, to wykonywanie wszystkich tych wątków powinno zostać przerwane. Java pozwala tworzyć w tym celu grupy wątków. Grupę wątków tworzymy, wywołując konstruktor klasy 6JTGCF)TQWR: 5VTKPI ITQWR0COG 6JTGCF)TQWR I PGY 6JTGCF)TQWR ITQWR0COG Łańcuch znaków będący parametrem konstruktora identyfikuje grupę wątków i musi być uni- kalny. Wątki dodajemy do danej grupy, określając ją za pomocą parametru konstruktora wątku. 6JTGCF V PGY 6JTGCF I VJTGCF0COG Aby dowiedzieć się, czy istnieje jakiś wykonywalny wątek danej grupy, u ywamy metody CEVKXG%QWPV. KH ICEVKXG%QWPV ] YU[UVMKG YæVMK FCPGL ITWR[ CMQ E[ [ FKC CPKG _

103. 38 Java 2. Techniki zaawansowane Aby przerwać wykonywanie wszystkich wątków danej grupy, wywołujemy metodę KPVGT TWRV obiektu reprezentującego daną grupę. IKPVGTTWRV RTGT[YC YU[UVMKG YæVMK Y ITWRKG I Ten sam efekt mo emy osiągnąć bez u ywania grup wątków, lecz za pomocą egzekutorów (patrz strona 88.). Grupy wątków mogą posiadać podgrupy. Domyślnie nowo tworzona grupa wątków staje się podgrupą bie ącej grupy. Grupę nadrzędną mo na tak e określić za pomocą parametru konstruktora grupy (patrz opis konstruktora). Metody CEVKXG%QWPV oraz KPVGTTWRV odnoszą się do wszystkich wątków w grupie oraz jej podgrup. LCXCNCPI6JTGCF n 6JTGCF 6JTGCF)TQWR I 5VTKPI PCOG tworzy nowy wątek nale ący do danej grupy wątków. Parametry: I grupa wątków, do której nale eć będzie nowy wątek, PCOG nazwa nowego wątku. n 6JTGCF)TQWR IGV6JTGCF)TQWR zwraca grupę wątków, do której nale y dany wątek. LCXCNCPI6JTGCF)TQWR n 6JTGCF)TQWR 5VTKPI PCOG tworzy nową grupę wątków. Grupa ta stanowić będzie podgrupę grupy, do której nale y bie ący wątek. Parametry: PCOG nazwa nowej grupy wątków. n 6JTGCF)TQWR 6JTGCF)TQWR RCTGPV 5VTKPI PCOG tworzy nową grupę wątków. Parametry: RCTGPV grupa nadrzędna tworzonej grupy, PCOG nazwa nowej grupy wątków. n KPV CEVKXG%QWPV zwraca liczbę wątków aktywnych danej grupy. n KPV GPWOGTCVG 6JTGCF=? NKUV pobiera referencje do wszystkich wątków aktywnych w danej grupie; aby określić rozmiar tablicy referencji, warto u yć metody CEVKXG%QWPV; mo e zdarzyć się, e tablica oka e się za mała (na przykład gdy po u yciu metody CEVKXG%QWPV utworzono du o nowych wątków), wtedy znajdą się w niej referencje do części wątków. Parametry: NKUV tablica, w której mają znaleźć się referencję wątków. n 6JTGCF)TQWR IGV2CTGPV pobiera grupę nadrzędną danej grupy. n XQKF KPVGTTWRV przerywa wszystkie wątki danej grupy i jej wszystkich podgrup.

104. Rozdział 1. n Wielowątkowość 39 Procedury obsługi wyjątków Metoda TWP wątku nie mo e wygenerować weryfikowalnego wyjątku, ale jej działanie mo- e zostać zakończone przez wyjątek nieweryfikowalny. W takim przypadku wątek kończy swoje istnienie. W sytuacji tej nie istnieje klauzula ECVEJ, do której mogłaby zostać przekazana obsługa wyjątku. Dlatego te , zanim wątek zakończy działanie, obsługa wyjątku zostaje przekazana do procedury obsługi wyjątków. Procedura ta musi nale eć do klasy, która implementuje interfejs 6JTGCF7PECWIJV'ZEGR VKQP*CPFNGT. Interfejs ten składa się z pojedynczej metody XQKF WPECWIJV'ZEGRVKQP 6JTGCF V 6JTQYCDNG G Począwszy od JDK 5.0 metoda UGV7PECWIJV'ZEGRVKQP*CPFNGT pozwala nam zainstalować własną procedurę obsługi wyjątków dla dowolnego wątku. Metoda statyczna UGVGHCWNV 7PECWIJV'ZEGRVKQP*CPFNGT nale ąca do klasy 6JTGCF umo liwia zainstalowanie domyślnej procedury obsługi wyjątków dla wszystkich wątków programu. Procedura taka mo e, na przykład, u ywać interfejsu programowego dzienników do tworzenia raportów o wyjątkach nieobsłu onych. Jeśli nie zainstalujemy domyślnej procedury obsługi wyjątków dla wszystkich wątków, to będzie ona PWNN. Natomiast gdy nie zainstalujemy takiej procedury dla poszczególnych wątków, to procedura ta nale eć będzie do obiektu 6JTGCF)TQWR dla danego wątku. Klasa 6JTGCF)TQWR implementuje interfejs 6JTGCF7PECWIJV'ZEGRVKQP*CPFNGT. Metoda WPE CWIJV'ZEGRVKQP tej klasy wykonuje podejmuje następujące działania: 1. Jeśli dana grupa wątków nale y do grupy nadrzędnej, to wywoływana jest metoda WPECWIJV'ZEGRVKQP grupy nadrzędnej. 2. W przeciwnym razie, jeśli metoda 6JTGCFIGVGHCWNV'ZEGRVKQP*CPFNGT zwraca procedurę obsługi ró ną od PWNN, to zostaje ona wywołana. 3. W przeciwnym razie, gdy 6JTQYCDNG jest instancją 6JTGCFGCVJ, nie jest wykonywana adna operacja. 4. W przeciwnym razie nazwa wątku i zrzut stosu dla 6JTQYCDNG zostają zapisane w 5[UVGOGTT. Wspomniany zrzut stosu znany jest dobrze wszystkim piszącym programy w języku Java. W wersjach wcześniejszych niż JDK 5.0 nie istniała bezpośrednia możliwość zainsta- lowania własnej procedury obsługi wyjątków dla wszystkich wątków ani dla poszcze- gólnych wątków. W tym celu należało stworzyć klasę pochodną klasy 6JTGCF)TQWR i przesłonić jej metodę WPECWIJV'ZEGRVKQP własną wersją.

105. 40 Java 2. Techniki zaawansowane LCXCNCPI6JTGCF n UVCVKE XQKF UGVGHCWNV7PECWIJV'ZEGRVKQP*CPFNGT 6JTGCF7PECWIJV'ZEGRVKQP *CPFNGT JCPFNGT 5.0 n UVCVKE 6JTGCF7PECWIJV'ZEGRVKQP*CPFNGT IGVGHCWNV7PECWIJV'ZEGRVKQP*CPFNGT 5.0 konfiguruje lub pobiera domyślną procedurę obsługi wyjątków. n XQKF UGV7PECWIJV'ZEGRVKQP*CPFNGT 6JTGCF7PECWIJV'ZEGRVKQP*CPFNGT JCPFNGT 5.0 n 6JTGCF7PECWIJV'ZEGRVKQP*CPFNGT IGV7PECWIJV'ZEGRVKQP*CPFNGT 5.0 konfiguruje lub pobiera procedurę obsługi wyjątków. Jeśli adna taka procedura nie zostanie skonfigurowana, to u ywana jest w tym celu grupa, do której nale y wątek. LCXCNCPI6JTGCF7PECWIJV'ZEGRVKQP*CPFNGT n XQKF WPECWIJV'ZEGRVKQP 6JTGCF V 6JTQYCDNG G. Metodę tę definiujemy, aby uzyskać raport, gdy działanie wątku zostało zakończone na skutek nieobłu onego wyjątku. Parametry: V wątek zakończony na skutek wyjątku, który nie został obsłu ony, G wyjątek, który nie został obsłu ony. LCXCNCPI6JTGCF)TQWR n XQKF WPECWIJV'ZEGRVKQP 6JTGCF V 6JTQYCDNG G. Metodę tę zastępujemy własną wersją, aby reagować na wyjątki powodujące zakończenie wątków tej grupy. Domyślna implementacja wywołuje tę samą metodę grupy nadrzędnej, a jeśli grupa nadrzędna nie istnieje, to wysyła zrzut stosu do standardowego strumienia błędów. (Jeśli G jest obiektem klasy 6JTGCFGCVJ, to informacja o zawartości stosu nie jest wysyłana. Obiekty klasy 6JTGCFGCVJ generowane są przez metodę UVQR, której nie nale y stosować).

Java 2. Techniki zaawansowane. Wydanie II

More Related Content

What's hot (9)

Viewers also liked (14)

Similar to Java 2. Techniki zaawansowane. Wydanie II (20)

More from Wydawnictwo Helion (20)

Java 2. Techniki zaawansowane. Wydanie II