java 2. techniki zaawansowane. wydanie ii

Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Java 2. Technikizaawansowane.Wydanie IIAutorzy: Cay Horstmann, Gary Cornell

T³umaczenie: Jaromir Senczyk

ISBN: 83-7361-842-2

Tytu³ orygina³u: Core Java(TM) 2, Volume II

— Advanced Features (7th Edition)

Format: B5, stron: 1144

Przyk³ady na ftp: 1644 kB

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

• Szczegó³owe omówienie wielow¹tkowo�ci, kolekcji, programowania aplikacji

sieciowych i bazodanowych, bezpieczeñstwa i internacjonalizacji aplikacji,

obiektów rozproszonych i jêzyka XML

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

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

mo¿liwo�ci biblioteki Swing i klas wykorzystywanych do tworzenia aplikacji bazodanowych

i sieciowych. „Java 2. Techniki zaawansowane. Wydanie II” przedstawia i opisuje wszystkie

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

• Interfejs JDBC i LDAP

• Aplikacje rozproszone

• Technologia CORBA

• Zaawansowane mo¿liwo�ci bibliotek Swing i AWT

• 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.

http://helion.pl/view/2547w



http://helion.pl/add/2547w/jv2te2




mailto:[email protected]

http://helion.pl/view/2547w/jv2te2.htm

http://www.amazon.com/exec/obidos/ASIN/0131118269/eboinf-20

http://www.amazon.com/exec/obidos/ASIN/0131118269/eboinf-20

ftp://ftp.helion.pl/przyklady/jv2te2.zip

Spis treści

Podziękowania........................................................................................................................................... 11

Przedmowa............................................................................................................................................... 13

Do Czytelnika..............................................................................................................13O książce ...................................................................................................................13

Rozdział 1. Wielowątkowość .................................................................................................................... 17

Czym są wątki?...........................................................................................................18Zastosowanie wątków.............................................................................................23

Przerywanie wątków.....................................................................................................29Stany wątków .............................................................................................................32

Nowe wątki ...........................................................................................................32Wątki wykonywalne.................................................................................................33Wątki zablokowane.................................................................................................33Wątki martwe ........................................................................................................35

Właściwości wątków ....................................................................................................36Priorytety wątków ...................................................................................................36Wątki-demony ........................................................................................................37Grupy wątków ........................................................................................................37Procedury obsługi wyjątków .....................................................................................39

Synchronizacja............................................................................................................40Przykład wyścigu ....................................................................................................41Wytłumaczenie wyścigu...........................................................................................45Blokady.................................................................................................................46Warunki ................................................................................................................49Słowo kluczowe synchronized ..................................................................................54Bloki synchronizowane............................................................................................60Pola volatile ..........................................................................................................61Zakleszczenia ........................................................................................................63Równorzędne traktowanie wątków............................................................................65Testowanie blokad i limity czasu..............................................................................65Blokady odczytu i zapisu .........................................................................................67Dlaczego metody stop i suspend nie są zalecane? ....................................................68

Kolejki blokujące.........................................................................................................70Kolekcje.....................................................................................................................76

Efektywne implementacje kolejki i tablicy mieszającej ................................................76Kolekcje CopyOnWriteArrayList i CopyOnWriteArraySet................................................78Starsze kolekcje i wielowątkowość...........................................................................78

4 Java 2. Techniki zaawansowane

Interfejsy Callable i Future............................................................................................78Egzekutory..................................................................................................................83

Pule wątków ..........................................................................................................83Wykonywanie zadań według planu............................................................................87Sterowanie grupami wątków ....................................................................................88

Synchronizatory...........................................................................................................89Bariery ..................................................................................................................90Rejestry odliczające................................................................................................91Przekaźniki ............................................................................................................91Kolejki synchroniczne .............................................................................................91Semafory ..............................................................................................................92

Wątki i Swing..............................................................................................................98Zasada pojedynczego wątku....................................................................................99Wątek roboczy i Swing ..........................................................................................104

Rozdział 2. Kolekcje..................................................................................................................................111

Interfejsy kolekcji ......................................................................................................111Rozdzielenie interfejsów kolekcji od ich implementacji..............................................112Interfejsy Collection i Iterator w bibliotekach języka Java...........................................114

Kolekcje konkretne....................................................................................................119Listy powiązane ...................................................................................................120Klasa ArrayList ....................................................................................................128Zbiory z kodowaniem mieszającym.........................................................................129Zbiory drzewiaste .................................................................................................132Kolejki z priorytetami ............................................................................................138Mapy ..................................................................................................................139Specjalizowane klasy zbiorów i map .......................................................................144

Szkielet kolekcji ........................................................................................................149Widoki i opakowania.............................................................................................152Operacje masowe ................................................................................................158Wykorzystanie biblioteki kolekcji z tradycyjnymi bibliotekami .....................................159Rozbudowywanie szkieletu ....................................................................................160

Algorytmy .................................................................................................................163Sortowanie i tasowanie.........................................................................................164Wyszukiwanie binarne...........................................................................................167Proste algorytmy ..................................................................................................168Programowanie własnych algorytmów .....................................................................169

Tradycyjne kolekcje....................................................................................................171Klasa Hashtable ..................................................................................................171Wyliczenia ...........................................................................................................171Zbiory właściwości ...............................................................................................172Stosy..................................................................................................................173Zbiory bitów.........................................................................................................173

Rozdział 3. Programowanie aplikacji sieciowych ................................................................................ 179

Połączenia z serwerem ..............................................................................................179Implementacja serwerów............................................................................................183

Obsługa wielu klientów .........................................................................................186Wysyłanie poczty elektronicznej...................................................................................189Połączenia wykorzystujące URL ...................................................................................193

URL i URI ............................................................................................................194Zastosowanie klasy URLConnection do pobierania informacji ....................................196Wysyłanie danych do formularzy.............................................................................205

Spis treści 5

Zaawansowane programowanie przy użyciu gniazdek sieciowych.....................................214Limity czasu gniazdek...........................................................................................214Przerywanie operacji gniazdek ...............................................................................215Połączenia częściowo zamknięte............................................................................219Adresy internetowe...............................................................................................220

Rozdział 4. Połączenia do baz danych: JDBC........................................................................................ 225

Architektura JDBC .....................................................................................................226Typy sterowników JDBC.........................................................................................227Typowe zastosowania JDBC ..................................................................................228

Język SQL.................................................................................................................230Instalacja JDBC.........................................................................................................235Podstawowe koncepcje programowania przy użyciu JDBC...............................................235

Adresy URL baz danych.........................................................................................236Nawiązywanie połączenia ......................................................................................236Wykonywanie poleceń języka SQL ..........................................................................241Zaawansowane typy języka SQL .............................................................................242Zarządzanie połączeniami, poleceniami i zbiorami wyników.......................................245Wypełnianie bazy danych.......................................................................................246

Wykonywanie zapytań ................................................................................................249Polecenia przygotowane........................................................................................250

Przewijalne i aktualizowalne zbiory wyników zapytań ......................................................258Przewijalne zbiory rekordów ...................................................................................259Aktualizowalne zbiory rekordów..............................................................................262

Metadane.................................................................................................................266Zbiory rekordów ........................................................................................................275

Buforowane zbiory rekordów ..................................................................................276Transakcje................................................................................................................285

Punkty kontrolne ..................................................................................................286Aktualizacje wsadowe (JDBC 2) .............................................................................286

Zaawansowane zarządzanie połączeniami ....................................................................289Wprowadzenie do LDAP..............................................................................................290

Konfiguracja serwera LDAP....................................................................................291Dostęp do informacji katalogu LDAP.......................................................................294

Rozdział 5. Obiekty rozproszone .......................................................................................................... 305

Role klienta i serwera ................................................................................................306Wywołania zdalnych metod.........................................................................................308

Namiastka i szeregowanie parametrów...................................................................309Dynamiczne ładowanie klas...................................................................................311

Konfiguracja wywołania zdalnych metod .......................................................................312Interfejsy i implementacje .....................................................................................312Generowanie klasy namiastki ................................................................................315Odnajdywanie obiektów serwera ............................................................................315Po stronie klienta.................................................................................................319Przygotowanie wdrożenia.......................................................................................324Wdrożenie programu.............................................................................................326

Przekazywanie parametrów zdalnym metodom..............................................................329Przekazywanie lokalnych obiektów..........................................................................329Przekazywanie zdalnych obiektów...........................................................................341Zdalne obiekty i metody equals oraz hashCode .......................................................343Klonowanie zdalnych obiektów...............................................................................344


Aktywacja obiektów serwera .......................................................................................344Java IDL i CORBA ......................................................................................................350

Język IDL.............................................................................................................351Przykład aplikacji CORBA.......................................................................................356Implementacja serwerów CORBA ...........................................................................365

Wywołania zdalnych metod i SOAP ..............................................................................370

Rozdział 6. Zaawansowane możliwości pakietu Swing....................................................................... 377

Listy ........................................................................................................................377Komponent JList ..................................................................................................378Modele list ..........................................................................................................384Wstawianie i usuwanie .........................................................................................388Odrysowywanie zawartości listy..............................................................................390

Drzewa.....................................................................................................................395Najprostsze drzewa ..............................................................................................396Przeglądanie węzłów.............................................................................................411Rysowanie węzłów................................................................................................412Nasłuchiwanie zdarzeń w drzewach ........................................................................419Własne modele drzew...........................................................................................425

Tabele .....................................................................................................................433Najprostsze tabele ...............................................................................................433Modele tabel .......................................................................................................436Filtry sortujące .....................................................................................................445Rysowanie i edytowanie zawartości komórek...........................................................451Operacje na wierszach i kolumnach........................................................................464Wybór wierszy, kolumn i komórek...........................................................................465

Komponenty formatujące tekst ...................................................................................473Wskaźniki postępu ....................................................................................................479

Paski postępu .....................................................................................................480Monitory postępu .................................................................................................484Monitorowanie postępu strumieni wejścia...............................................................489

Organizatory komponentów.........................................................................................494Panele dzielone ...................................................................................................495Panele z zakładkami.............................................................................................499Panele pulpitu i ramki wewnętrzne .........................................................................504Rozmieszczenie kaskadowe i sąsiadujące...............................................................507Zgłaszanie weta do zmiany właściwości ..................................................................510

Rozdział 7. Zaawansowane możliwości biblioteki AWT........................................................................ 521

Potokowe tworzenie grafiki .........................................................................................522Figury.......................................................................................................................524

Wykorzystanie klas obiektów graficznych.................................................................526Pola.........................................................................................................................539Ślad pędzla ..............................................................................................................543Wypełnienia..............................................................................................................550Przekształcenia układu współrzędnych.........................................................................556Przycinanie ...............................................................................................................565Przezroczystość i składanie obrazów............................................................................569Wskazówki operacji graficznych...................................................................................577Czytanie i zapisywanie plików graficznych.....................................................................583

Wykorzystanie obiektów zapisu i odczytu plików graficznych ......................................583Odczyt i zapis plików zawierających sekwencje obrazów............................................585

Spis treści 7

Operacje na obrazach ................................................................................................595Dostęp do danych obrazu......................................................................................595Filtrowanie obrazów..............................................................................................602

Drukowanie ..............................................................................................................610Drukowanie grafiki................................................................................................611Drukowanie wielu stron.........................................................................................621Podgląd wydruku..................................................................................................623Usługi drukowania................................................................................................631Usługi drukowania za pośrednictwem strumieni .......................................................637Atrybuty drukowania .............................................................................................642

Schowek ..................................................................................................................649Klasy i interfejsy umożliwiające przekazywanie danych..............................................650Przekazywanie tekstu ...........................................................................................651Interfejs Transferable i formaty danych ...................................................................655Przekazywanie obrazów za pomocą schowka ...........................................................657Wykorzystanie lokalnego schowka do przekazywania referencji obiektów.......................662Wykorzystanie schowka systemowego do przekazywania obiektów Java......................668

Mechanizm „przeciągnij i upuść”.................................................................................672Cele mechanizmu „przeciągnij i upuść” ..................................................................674Źródła mechanizmu „przeciągnij i upuść”................................................................683Przekazywanie danych pomiędzy komponentami Swing.............................................688

Rozdział 8. JavaBeans........................................................................................................................... 693

Dlaczego ziarnka? .....................................................................................................694Proces tworzenia ziarnek JavaBeans ...........................................................................695Wykorzystanie ziarnek do tworzenia aplikacji ................................................................698

Umieszczanie ziarnek w plikach JAR.......................................................................699Korzystanie z ziarnek............................................................................................700

Wzorce nazw właściwości ziarnek i zdarzeń ..................................................................705Typy właściwości ziarnek ............................................................................................708

Właściwości proste ..............................................................................................708Właściwości indeksowane.....................................................................................709Właściwości powiązane.........................................................................................710Właściwości ograniczone ......................................................................................712

Klasa informacyjna ziarnka.........................................................................................718Edytory właściwości ...................................................................................................723

Implementacja edytora właściwości........................................................................730Indywidualizacja ziarnka .............................................................................................744

Implementacja klasy indywidualizacji ......................................................................746Trwałość ziarnek JavaBeans .......................................................................................753

Zastosowanie mechanizmu trwałości JavaBeans dla dowolnych danych......................758Kompletny przykład zastosowania trwałości JavaBeans ............................................764

Rozdział 9. Bezpieczeństwo .................................................................................................................. 775

Ładowanie klas.........................................................................................................776Implementacja własnej procedury ładującej.............................................................779

Weryfikacja kodu maszyny wirtualnej ...........................................................................784Menedżery bezpieczeństwa i pozwolenia ......................................................................789

Bezpieczeństwo na platformie Java 2 .....................................................................791Pliki polityki bezpieczeństwa..................................................................................794Tworzenie własnych klas pozwoleń.........................................................................801Implementacja klasy pozwoleń...............................................................................802


Tworzenie własnych menedżerów bezpieczeństwa....................................................808Uwierzytelnianie użytkowników...............................................................................815Moduły JAAS........................................................................................................820

Podpis cyfrowy ..........................................................................................................829Skróty wiadomości ...............................................................................................830Podpisywanie wiadomości.....................................................................................835Uwierzytelnianie wiadomości .................................................................................843Certyfikaty X.509 .................................................................................................845Tworzenie certyfikatów..........................................................................................847Podpisywanie certyfikatów.....................................................................................849

Podpisywanie kodu....................................................................................................857Podpisywanie plików JAR.......................................................................................857Certyfikaty twórców oprogramowania ......................................................................861

Szyfrowanie ..............................................................................................................863Szyfrowanie symetryczne.......................................................................................863Strumienie szyfrujące ...........................................................................................870Szyfrowanie kluczem publicznym............................................................................871

Rozdział 10. Internacjonalizacja ........................................................................................................... 877

Lokalizatory ..............................................................................................................878Formaty liczby ...........................................................................................................883

Waluty ................................................................................................................889Data i czas ...............................................................................................................890Porządek alfabetyczny................................................................................................897Formatowanie komunikatów .......................................................................................905

Formatowanie z wariantami ...................................................................................907Pliki tekstowe i zbiory znaków .....................................................................................909

Internacjonalizacja a pliki źródłowe programów ........................................................909Komplety zasobów ....................................................................................................910

Lokalizacja zasobów.............................................................................................911Pliki właściwości ..................................................................................................912Klasy 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 ..................................................931Wykorzystanie funkcji printf ...................................................................................932

Numeryczne parametry metod i wartości zwracane........................................................937Wykorzystanie funkcji printf do formatowania liczb ...................................................937

Łańcuchy znaków jako parametry ................................................................................938Wywołanie funkcji sprintf przez metodę macierzystą.................................................942

Dostęp do składowych obiektu ...................................................................................944Dostęp do pól instancji .........................................................................................944Dostęp do pól statycznych ....................................................................................949

Sygnatury .................................................................................................................949Wywoływanie metod języka Java..................................................................................951

Wywoływanie metod obiektów................................................................................951Wywoływanie metod statycznych ............................................................................952Konstruktory........................................................................................................953Alternatywne sposoby wywoływania metod ..............................................................954

Tablice.....................................................................................................................958Obsługa błędów ........................................................................................................963

Spis treści 9

Interfejs programowy wywołań języka Java....................................................................967Kompletny przykład: dostęp do rejestru systemu Windows.............................................971

Rejestr systemu Windows .....................................................................................971Interfejs dostępu do rejestru na platformie Java ......................................................972Implementacja dostępu do rejestru za pomocą metod macierzystych .........................973

Rozdział 12. Język XML ......................................................................................................................... 987

Wprowadzenie do języka XML .....................................................................................988Struktura dokumentu XML.....................................................................................990

Parsowanie dokumentów XML ....................................................................................993Kontrola poprawności dokumentów XML ....................................................................1003

Definicje typów dokumentów ...............................................................................1005XML Schema .....................................................................................................1012Praktyczny przykład ............................................................................................1014

Wyszukiwanie infomacji i XPath.................................................................................1028Przestrzenie nazw....................................................................................................1033Wykorzystanie parsera SAX ......................................................................................1036Tworzenie dokumentów XML.....................................................................................1041Przekształcenia XSL.................................................................................................1049

Rozdział 13. Adnotacje .......................................................................................................................... 1059

Umieszczanie metadanych w programach ..................................................................1060Przykład — adnotacje obsługi zdarzeń .......................................................................1061Składnia adnotacji...................................................................................................1066Adnotacje standardowe............................................................................................1070

Adnotacje regularne ...........................................................................................1070Metaadnotacje...................................................................................................1071

Narzędzie apt do przetwarzania adnotacji w kodzie źródłowym ......................................1074Inżynieria kodu bajtowego ........................................................................................1080

Modyfikacja kodu bajtowego podczas ładowania....................................................1089

Skorowidz............................................................................................................................................. 1093

1Wielowątkowość

W tym rozdziale:

� Czym są wątki?

� Przerywanie wątków.

� Stany wątków.

� Właściwości wątków.

� Synchronizacja.

� Kolejki blokujące.

� Kolekcje.

� Interfejsy Callable i Future.

� Egzekutory.

� Synchronizatory.

� Wątki i Swing.

Czytelnik z pewnością wie, że wielozadaniowość oznacza możliwość pracy wielu programówrównocześnie. Dzięki wielozadaniowości możemy w czasie edycji dokumentu drukować innydokument bądź wysyłać faks. Oczywiście wtedy, gdy mamy do dyspozycji tylko maszynęo pojedynczym procesorze, uzyskujemy jedynie wrażenie równoczesnego wykonywaniawielu programów, ponieważ system operacyjny przydziela czas procesora kolejnym zada-niom. Takie zarządzanie przydziałem procesora jest tym bardziej możliwe, że wiele zadań ab-sorbuje 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 proceso-ra kolejnym zadaniom, natomiast w drugim wykonywanie zadania może zostać przerwanetylko wtedy, jeśli zgodzi się ono oddać sterowanie. Starsze systemy operacyjne, takie jakWindows 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ówkomó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ść


z wywłaszczaniem. Chociaż realizacja wielozadaniowości z wywłaszczaniem jest dużotrudniejsza, 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żewykonywać równocześnie wiele zadań. Zadania te nazywamy wątkami. Program, który wyko-nuje 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 za-danie dysponuje własnym oddzielnym zestawem danych (zmiennych), to wątki operują nawspólnych danych. Utworzenie bądź usunięcie wątku wiąże się z dużo mniejszym nakłademze strony systemu operacyjnego niż w przypadku tych samych operacji dla zadania. Podobniekomunikacja 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 pocztyelektronicznej umożliwia czytania poczty, w trakcie pobierając nowe wiadomości. Także Javauż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 in-formacji 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 im-plementacji mechanizmów wielowątkowych. W rozdziale tym omówimy nowe możliwościJDK 5.0, a także klasyczne mechanizmy synchronizacji i pomożemy Ci dokonać właściwegowyboru pomiędzy nimi.

Wielowątkowość nie jest prostym zagadnieniem. W rozdziale tym przedstawiamy wszyst-kie narzędzia, które udostępnia język Java do programowania wątków. Wyjaśniamy przytym 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 jednakskorzystać z bardziej specjalistycznej literatury, na przykład Concurrent Programming inJava 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 po-każemy, jak łatwo usunąć te niedogodności, wprowadzając do programu wątki. Programten 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órnymrogu okienka piłki, która rozpoczyna swój ruch. Metoda obsługi zdarzenia dla przyciskuStart wywołuje metodę ��. Metoda ta zawiera pętlę, w której 1000 razy wykonywanajest metoda �� powodująca niewielkie przesunięcie rysunku piłki, ewentualną zmianękierunku ruchu w przypadku odbicia od ramki i odrysowanie tła okna.

Rozdział 1. � Wielowątkowość 19

Rysunek 1.1.

Animacja piłkiodbijającej sięod ramki okienka

��

�� !�� "�� #�$!��#��!�� %�&'(��)

Metoda statyczna �� klasy �� powoduje zawieszenie wykonywania pętli na okre-śloną liczbę milisekund.

Wywołanie metody �� nie tworzy nowego wątku — metoda �� jest sta-tyczną metodą klasy �� , która powoduje wstrzymanie wykonywania aktywnego wąt-ku na określony czas.

Metoda �� może spowodować wystąpienie wyjątku �� . Wyjątek tenoraz sposób jego obsługi omówimy dokładniej w dalszej części rozdziału. W obecnej wer-sji programu jego wystąpienie spowoduje jedynie przerwanie animacji.

Animacja ruchu piłki w obecnej wersji programu absorbuje całkowicie jedyny wątek apli-kacji w jej obecnej postaci. Jeśli użytkownik zechce, zanim pętla wykona się 1000 razy,przerwać działanie programu, wybierając przycisk ��, to nie przyniesie to zamierzonegoefektu. 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

$��!� ��$��!��"�� #�$!��

wewnątrz metody �� klasy ��. Rozwiązanie to może wydawać się dziwne, ponie-waż zwykle wywołujemy metodę �� i pozwalamy AWT zająć się określeniem kon-tekstu graficznego i odrysowaniem zawartości okna. Jednak jeśli postąpimy w tensposób także w tym programie, to odrysowanie nie będzie mogło się odbyć, ponieważ

metoda �� zmonopolizowała przetwarzanie. W następnej wersji programu, którabędzie obliczać kolejne pozycji piłki w osobnym wątku, z powrotem będziemy mogli za-

stosować wywołanie metody ��.


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 je-go fragmentu użytkownik stwierdzi, że nie interesuje go całość, to wybranie przycisku Stoplub Back powinno spowodować przerwanie procesu ładowania. W dalszej części rozdziałupokażemy, w jaki sposób można zapewnić użytkownikowi pełną kontrolę nad działaniemprogramu 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

�� *��+�� *��+�� *��+�� *�� +�� *��,�!��+�

-++��'��$*��*�*.$�*�!�/� �01��+- ��$�$��!!�� $�� $�!��$��23��!��45�� $�5��!��%�� 6��!�7 ��45��89�:7;:6&7��!��<�!�� ))

-++��01�� !=�*.$��!�/��*�*.$��1��/�=��1�� +-$��!!��-++��=�! �� 01/��!�/ ��*� �=>$*�?�=��*.$�1�� 1�� $# ?��*�@��1��/�A��+-�� $��B�$��C%�� !��,��,��>��>��,�� !��D��8��,�� !��D��8��,��E�,��)��,��8�9F��G�� !��D�,8��,�� !��D�,8��E�8�9F��,��E�,��)


��>�� !��D��(��>�� !��D��(��>��E�>��)��>��(�9F��G�� !��D�,(��>�� !��D�,(��E�(�9F��>��E�>��)��)

��-++��=>�1!=��0�� 01��H.$�*� �=>$*��+-�� $�� !�C%��#� �� !�C%�%� ��,?�>?�8�9F�?�(�9F��)

�� !��$��8�9F��I�� !��$��(�9F��I�� ,��J�� >��J�� ,�� >��)

-++��>! *.$>� �01��+-$��!!��,��!�4��-++��%��*�� 01/�� K �� 01��+-�� $��!��)

�� $�� 6�� "�� #�$!��! �� 6�� "�� #�$!C%��C��"�� #�$!C%��L��!��C��#� ��)��)

�� '��>&�!��G��!��'��>&�!��G��)

-++��B��1��=��*.$��0�� =>$�!1��


+-$��!!�� $�5��,��!�45��-++��M��!�� *��1/�=��*.$.� ��?��1�N��*��/�=�� 01�� 1�=�� =>$�!1��6��!�

��+-�� $�� $�5��!��=�%�5'O&�:P9%�Q?�%�5'O&�:Q�9"Q��!��R�� $�R��

�� ?��&�>� ��6�;��B��4�� 4�� ?�R��R?��'$��&�!�� $��$��'$��)��)��

�� ?�R6��!�R?��'$��&�!�� $��$��'$��>!��,��J��)��)�� ?��&�>� ��7O�Q��)

��-++��%��*�� =>$�!1��1��K ��$�1��K ��=�� =>$�!1 ��K ��!��1��!0 $# *.$>� �=>$�!1

��+-�� $�� 6��$?��?�'$��&�!��!��4� �� 4� ��$�� '$��&�!��!��)

��-++��%��*�� 01/�� B>! *�� 01/�� *��*.��JJJ��=>��+-�� $��>


��

�� !�� "�� #�$!��#��!�� %�&'(��)��)��$��$#�9�� ,$� ��)��)

�� $�!��$��%�5'O&�:P9%�Q��SIJ�� $�!��$��%�5'O&�:Q�9"Q��TIJ�� $�!��$��JJJ�� $�!��$��%�&'(��T�)

��

� �� zawiesza wykonanie wątku na określoną liczbęmilisekund.

Parametry: �� 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 nawetanimować 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ż wszystkiewą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 �� klasy implementującejinterfejs ��. Interfejs ten jest bardzo prosty i posiada tylko jedną metodę:

��$��$��B �� )

Klasę implementującą ten interfejs tworzymy w następujący sposób:


$��!!�D>B �� !�B �� $�� ))

2. Następnie tworzymy obiekt naszej klasy:

B ��D>B ��

3. Tworzymy obiekt �� na podstawie obiektu ��:

�#��#��

4. Uruchamiamy wątek:

��!��

Aby kod animacji piłki wykonywany był we własnym wątku, wystarczy umieścić go we-wnątrz metody �� klasy ��:

$��!!��B �� !�B �� $�� >��$�� !��$�� #��!�� %�&'(��)��)��$��$#�9�� ,$� ��)��)��)

Powyższy fragment kodu zawiera także obsługę wyjątku �� , któregowystąpienie może spowodować metoda ��. Wyjątek ten omówimy w następnym punk-cie. Typowo, aby zakończyć wykonywanie wątku, przerywa się jego działanie. Zgodniez tą zasadą wystąpienie wyjątku �� spowoduje zakończenie wykony-wania naszej metody ��.

Za każdym razem, gdy użytkownik wybierze przycisk Start, metoda �� uruchamianowy wątek (patrz rysunek 1.2):

�� B ��B ��?� ��#��#��!��


Rysunek 1.2.

Animacjawielową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 �� :

$��!!�D>�#��,��!��#��

�

�� $��

��

��

��)

)

Następnie tworzymy obiekt tej klasy pochodnej i wywołujemy jego metodę �� . Roz-wiązanie takie nie jest jednak zalecane. Należy dążyć do oddzielenia wykonywanegozadania 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 �� — zostanie ona wywołana przez me-

todę �� , w momencie gdy wątek jest gotowy do rozpoczęcia działania. Bezpośred-nie wywołanie metody �� 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

�� *��+�� *��+�� *��+�� *�� +�� *��,�!��+�


-++��'��$*��*�*.$�*�!�/� �01��+- ��$�$��!!�� $��#�� $�!��$��23��!��45�� $�5��!��%�� 6��!�7 ��45��89�:7;:6&7��!��<�!�� ))

-++��'��$*��*�*.$�*�!�/� �01��+-$��!!��B �� !�B ��-++��M��!�� 1��K�� 01��K��1�� ?��1�N�>��/�=��+-�� $��B ��?�6�� 6�� $�� 6�� )

�� $�� >��$�� !��$�� #��!�� %�&'(��)��)��$��$#�9�� ,$� ��)��)

�� 6�� $�� $�!��$��JJJ�� $�!��$��%�&'(��I�)

-++��01�� !=�*.$��!�/��*�*.$��1��/�=��1�� +-$��!!��


��-++��=�! �� 01/��!�/ ��*� �=>$*�?�=��*.$�1�� 1�� $# ?��*�@��1��/�A��+-�� $��B�$��C%�� !��,��,��>��>��,�� !��D��8��,�� !��D��8��,��E�,��)��,��8�9F��G�� !��D�,8��,�� !��D�,8��E�8�9F��,��E�,��)��>�� !��D��(��>�� !��D��(��>��E�>��)��>��(�9F��G�� !��D�,(��>�� !��D�,(��E�(�9F��>��E�>��)��)

��-++��=>�1!=��0�� 01��H.$�*� �=>$*��+-�� $�� !�C%��#� �� !�C%�%� ��,?�>?�8�9F�?�(�9F��)

�� !��$��8�9F��I�� !��$��(�9F��I�� ,��J�� >��J�� ,�� >��)

-++��>! *.$>� �01/�+-$��!!��,��!�4��-++��%��*�� 01/�� K �� 01��+-�� $��!��


��)

�� $�� 6�� "�� #�$!��! �� 6�� "�� #�$!C%��C��"�� #�$!C%��L��!��C��#� ��)��)

�� '��>&�!��G��!��'��>&�!��G��)

-++��B��1��=��*.$�� =>$�!1��+-$��!!�� $�5��,��!�45��-++��M��!�� *��1/�=� ��?��1�N��*��/�=�� 01�� !=$=�� =>$�!1��6��!��+-�� $�� $�5��!��=�%�5'O&�:P9%�Q?�%�5'O&�:Q�9"Q��!��R�� $��#��R��

�� ?��&�>� ��6�;��B��4�� 4�� ?�R��R?��'$��&�!�� $��$��'$��)��)��

�� ?�R6��!�R?��'$��&�!�� $��$��'$��>!��,��J��)��)�� ?��&�>� ��7O�Q��)

��-++��%��*�� =>$�!1��1��K ��$�1��K ��=�� =>$�!1 ��K ��!��1��!0 $# *.$>� �=>$�!1 ��+-


�� $�� 6��$?��?�'$��&�!��!��4� �� 4� ��$�� '$��&�!��!��)

��-++��=>� �01/�� $#��>�.��1�*�*��$*��+-�� $�� B ��B ��?� ��#��#��!��)

�� $�!��$��%�5'O&�:P9%�Q��SIJ�� $�!��$��%�5'O&�:Q�9"Q��TIJ�� $�!��$��JJJ�� $�!��$��%�&'(��T�)

��

� �� tworzy nowy wątek, który wykonywać będzie metodęrun obiektu �� .

� �� uruchamia ten wątek i powoduje wywołanie metody ��. Metoda�� oddaje natychmiast sterowanie do metody, która ją wywołała, a nowy wątekwykonywany jest równolegle.

� �� wywołuje metodę �� odpowiedniego obiektu implementującegointerfejs ��.

��

� �� — tę metodę należy zastąpić własną wersją zawierającą kod, który mabyć wykonywany w nowym wątku.

Przerywanie wątków

Wykonanie wątku kończy się w momencie, gdy metoda �� zwraca sterowanie. (W pierw-szej wersji języka Java istniała także metoda ��, za pomocą której jeden wątek mógł za-kończyć wykonywanie innego. Obecnie metoda ta nie jest stosowana, a przyczyny tegoomówimy w dalszej części rozdziału).


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 �� .

Wywołanie metody �� powoduje nadanie wątkowi statusu przerwania. Status tenjest reprezentowany za pomocą znacznika logicznego. Wartość tego znacznika powinnabyć okresowo sprawdzana przez wątek.

Aby sprawdzić status przerwania wątku, należy najpierw wywołać metodę statyczną �� , aby uzyskać bieżący wątek, a następnie wywołać metodę �� sprawdzającą jego status:

#�� UU�!.��=��0��>1�� )

Jednak wątek, którego wykonywanie zostało zablokowane, nie może sprawdzić własnegostatusu przerwania. I właśnie w takim przypadku pomocny jest wyjątek �� . Jeśli metoda �� zostanie wywołana dla wątku, którego wykonanie jest zablo-kowane, to blokująca go metoda �� lub �� zostanie przerwana i pojawi się wyjątek�� .

Ś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ą onewyjątek i kontynuować będą swoje działanie. Najczęściej jednak wątek zinterpretuje wyją-tek jako żądanie zakończenia wykonywania. Metoda �� takiego wątku wygląda wtedy na-stępująco:

��$�� >��#��V�#��$ ��#��!9�� UU�!.��=��0��>1�� )

��)��$��$#9�� ,$� ��,$� ��--�.��1� �=��>��1$��>�!�� )��>�� )��--�=�1�W$=��>1��>��>�� >��!��>��.�1 )

Sprawdzenie statusu przerwania wątku za pomocą metody �� nie jest konieczne,gdy metoda �� wywoływana jest po każdej iteracji przetwarzania. Gdy wątek posiadastatus przerwania, to wywołanie metody �� spowoduje wystąpienie wyjątku ��


��. Dlatego też, gdy metoda �� wywoływana jest w pętli, to nie musimysprawdzać statusu przerwania wątku. Wystarczy jedynie zająć się obsługą wyjątku �� . Metoda �� posiada wtedy następującą postać:

��$�� >��#��!.��=��0��>1��>1��*��=��0��#��!�� >��)

��)��$��$#9�� ,$� ��,$� ��--�.��1� �=��>��1$��>�!�� )��>�� )��--�=�1�W$=��>1��>��>�� >��!��>��.�1 )

Wygenerowanie wyjątku �� przez metodę �� kasuje statusprzerwania wątku.

Istnieją dwie podobne metody, �� oraz �� . Metoda �� jest statyczną metodą, która sprawdza, czy bieżący wątek został przerwany. Dodatko-

wo wywołanie metody �� kasuje status przerwania wątku. Natomiast me-toda �� wywoływana jest dla konkretnej instancji wątku i umożliwia sprawdze-nie 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 �� jest pominięta, co widać poniżej:

��>��!�� >��)$��$#�9�� ,$� ��,$� ��)�--�X&�V

Nie wolno pisać programów w ten sposób! Jeśli nie wiemy, jak obsłużyć wyjątek w klau-zuli ��, to zawsze mamy jeszcze dwie inne możliwości:

� W klauzuli �� wywołać �� w celu nadaniawątkowi statusu przerwania, który może być sprawdzony przez kod wywołujący.

��>� ��!1��>��!�� >��)��$��$#�9�� ,$� ��#��$ ��#�� )��)


� Lepsze rozwiązanie polega na zadeklarowaniu metody jako �� i pominięciu bloku � . Dzięki temu kod wywołującymetodę (lub w końcu sama metoda ��) będzie mógł obsłużyć wyjątek.

��>� ��!1��#��!�9�� ,$� ��!�� >��)

��

� �� wysyła żądanie przerwania wątku. Status przerwania wątkuprzyjmuje wtedy wartość � ��. Jeśli wykonanie wątku jest zablokowane przezwywołanie metody �� lub ��, to występuje wyjątek �� .

� �� sprawdza, czy bieżący wątek (czyli ten, który jąwywołał) otrzymał żądanie przerwania. Zwróćmy uwagę, że jest to metodastatyczna. Jej wywołanie posiada efekt uboczny w postaci skasowania statusuprzerwania bieżącego wątku.

� �� sprawdza, czy wątek otrzymał żądanie przerwania.Nie powoduje skasowania statusu przerwania wątku w przeciwieństwie do metody�� .

� �� zwraca obiekt klasy �� reprezentującyaktualnie wykonywany wątek.

Stany wątków

Wątki mogą znajdować się w jednym z czterech stanów:

� nowym,

� wykonywalnym,

� zablokowanym,

� martwym.

Każdy z wymienionych stanów omówiomy w kolejnych podrozdziałach.

Nowe wątki

Kiedy tworzymy wątek za pomocą operatora �� — na przykład �� — nie jest onjeszcze wykonywany. Znajduje się wtedy w stanie nowy i kod w nim zawarty nie jest wy-konywany. Zanim zostanie uruchomiony, system musi wykonać jeszcze pewne operacje.


Wątki wykonywalne

Po wywołaniu metody �� wątek jest wykonywalny. Wykonywalny wątek nie musi byćod razu wykonywany. Przydział procesora zależy bowiem od systemu operacyjnego. Kiedyzostanie przydzielony, mówimy, że wątek jest wykonywany. (Dokumentacja języka Java nieprzewiduje 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ówcyklicznie zawieszał swoje wykonanie, dając tym samym szansę innym wątkom. Szczegółyszeregowania wątków zależą także od systemu operacyjnego. Systemy stosujące szerego-wanie 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 opera-cyjny 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ą szerego-wanie 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�� czy ��.

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ślijednak 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ższychsytuacji:

� Wywołana została metoda �� danego wątku.

� 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.

� Wątek próbuje zablokować dostęp do obiektu, który został już zablokowanyprzez inny wątek. Blokady obiektów omówimy w dalszej części tego rozdziału,na stronie 46.

� Wątek oczekuje na spełnienie pewnego warunku — patrz strona 49.

� Wywołana została metoda �� danego wątku. Nie jest ona obecnie stosowanai nie powinna być używana w programach. Przyczynę tego stanu rzeczy omówimyw dalszej części tego rozdziału.


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 wykonywa-nie bądź zakończyła się blokująca go operacja wejścia-wyjścia), program szeregujący wątkisprawdza, czy posiada on priorytet wyższy od aktualnie wykonywanego wątku. Jeśli tak, towywłaszcza bieżący wątek i rozpoczyna wykonywanie reaktywowanego wątku.

Rysunek 1.3.

Diagramstanów wątku

Wątek może powrócić ze stanu zablokowanego do stanu wykonywalnego, przebywając nadiagramie jedną z następujących dróg.

1. Jeśli wątek zawiesił wykonywanie wywołując metodę ��, 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ż oczekiwaniena zwolnienie blokady z określonym limitem czasu. Wtedy wątek zostajeodblokowany po jego upływie).

4. Jeśli wątek oczekuje na spełnienie pewnego warunku, to jego zajście musizostać zasygnalizowane przez inny wątek. (Możliwe jest również oczekiwaniena spełnienie warunku z określonym limitem czasu. Wtedy wątek zostajeodblokowany po jego upływie).

5. Jeśli wątek zawiesił swoje wykonywanie, to inny wątek musi wywołać jego metodę ��. Stosowanie metod �� i �� nie jest jednak zalecane.


Zablokowany wątek może powrócić do stanu wykonywalnego jedynie tą samą drogą, naktórej został zablokowany. W szczególności nie wystarczy wywołanie metody ��, abyodblokować 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 za-blokowany wątek powraca do stanu wykonywalnego, a blokująca operacja generuje wy-

jątek ��.

Wątki martwe

Wątek może być martwy gdy zaistnieje jeden z dwóch powodów.

� Zakończy się wykonywanie metody �� w prawidłowy sposób.

� Wykonanie metody �� 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 ��. Powodujeona wystąpienie błędu �� !��, co kończy wykonywanie wątku. Metoda ta niesie zesobą pewne zagrożenia (omówimy je w dalszej części rozdziału) i nie powinna być stoso-wana w programach.

Aby uzyskać informację o tym, czy dany wątek „żyje” (czyli jest wykonywalny lub zablo-kowany), stosujemy metodę �"��. Zwraca ona wartość logiczną � ��, gdy wątek jestwykonywalny lub zablokowany albo wartość #��, jeśli jest nowy bądź martwy.

Nie można uzyskać informacji o tym, czy dany wątek jest wykonywalny, czy też zablo-kowany, a także informacji o tym, czy jest w danej chwili wykonywany. Podobnie niemożna rozróżnić stanu wątku, w którym nie jest on jeszcze wykonywalny, od stanu,w którym jest już martwy.

��

� ��"�� zwraca wartość � ��, jeśli wątek już rozpoczął działaniei jeszcze się nie zakończył.

� �� kończy wykonanie wątku. Użycie tej metody nie jest zalecane.

� �� zawiesza wykonanie wątku. Użycie tej metody nie jest zalecane.

� �� podejmuje wykonanie wątku zawieszonego metodą ��.Użycie obu metod nie jest zalecane.

� ��$��oczekuje zakończenia działania określonego wątku.

� ��$��oczekuje zakończenia działania określonego wątkulub upływu �� milisekund.


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 jed-nak zmniejszyć lub zwiększyć, stosując metodę ��% �� . Za jej pomocą można prioryte-towi nadać dowolną wartość z przedziału od &�'(%��)��* (zdefiniowane jako 1 w klasie�� ) do &"+(%��)��* (zdefiniowane jako 10). Priorytet ')�&(%��)��* posiada wartość 5.

Gdy program szeregowania wątków musi wybrać nowy wątek, zawsze wybiera wątek wy-konywalny 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 opera-cyjnego. Jeśli maszyna wirtualna języka Java wykorzystuje zarządzanie wątkami danejplatformy, to musi dokonać odwzorowania priorytetów wątków zdefiniowanych w językuJava na poziomy priorytetów tej platformy (których może być mniej lub więcej niż wartościpriorytetó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 sampriorytet z punktu widzenia systemu operacyjnego. W przypadku maszyny wirtualnej Javafirmy 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 dlaprogramu 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 zawszewybiera najpierw spośród wątków o wyższym priorytecie, nawet jeśli w ten sposóbwątki o niższym priorytecie nie są nigdy wykonywane.

��

� ��% �� % �� określa priorytet wątku. Wartość priorytetumusi znajdować się w przedziale od �� &�'(%��)��* do �� &"+(%��)��*.Priorytet zwykłego wątku posiada wartość �� ')�&(%��)��*.

� ��&�'(%��)��* minimalna wartość priorytetu wątku (wynosi 1).

� ��')�&(%��)��* domyślna wartość priorytetu wątku (wynosi 5).


� ��&"+(%��)��* maksymalna wartość priorytetu wątku (wynosi 10).

� �� zawiesza wykonanie bieżącego wątku. Kolejnymwykonywanym wątkiem będzie wątek wykonywalny, o co najmniej takim samympriorytecie jak wątek zawieszony. Metoda statyczna.

Wątki-demony

Wątek staje się wątkiem-demonem przez wywołanie

��!��%��

Wątek-demon nie ma w sobie nic demonicznego. Jest to po prostu wątek, którego jedynymzadaniem 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 pro-gramu pozostaje jedynie wątek-demon, to program kończy swoje działania.

��

� ��!��!�� 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ńczyswoje 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śliwiele 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 powinnozostać przerwane. Java pozwala tworzyć w tym celu grupy wątków.

Grupę wątków tworzymy, wywołując konstruktor klasy �� , ��:

�� ;��#��"�� #��"�� ;��

Ł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.

�#��#��?��#��;��

Aby dowiedzieć się, czy istnieje jakiś wykonywalny wątek danej grupy, używamy metody��.

��$��6� ��J��--�!=>!�1��.�1��*�� >�=�1�W$=>0>��=��0��)


Aby przerwać wykonywanie wszystkich wątków danej grupy, wywołujemy metodę �� obiektu reprezentującego daną grupę.

�� --� �=��>��!=>!�1��.�1��

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 stajesię podgrupą bieżącej grupy. Grupę nadrzędną można także określić za pomocą parametrukonstruktora grupy (patrz opis konstruktora). Metody �� oraz �� odnosząsię do wszystkich wątków w grupie oraz jej podgrup.

��

� �� , ��-�.� �� tworzy nowy wątek należący do danej grupywątków.

Parametry: � grupa wątków, do której należeć będzie nowy wątek,

�� nazwa nowego wątku.

� �� , �� , �� zwraca grupę wątków, do której należy dany wątek.

��

� �� , ��.� �� tworzy nową grupę wątków. Grupa ta stanowić będziepodgrupę grupy, do której należy bieżący wątek.

Parametry: �� nazwa nowej grupy wątków.

� �� , �� , �� -�.� �� tworzy nową grupę wątków.

Parametry: � �� grupa nadrzędna tworzonej grupy,

�� nazwa nowej grupy wątków.

� �� zwraca liczbę wątków aktywnych danej grupy.

� �� /0�� pobiera referencje do wszystkich wątkówaktywnych w danej grupie; aby określić rozmiar tablicy referencji, warto użyćmetody ��; może zdarzyć się, że tablica okaże się za mała (na przykładgdy po użyciu metody �� utworzono dużo nowych wątków), wtedyznajdą się w niej referencje do części wątków.

Parametry: �� tablica, w której mają znaleźć się referencję wątków.

� �� , ��%� ��pobiera grupę nadrzędną danej grupy.

� �� przerywa wszystkie wątki danej grupy i jej wszystkich podgrup.


Procedury obsługi wyjątków

Metoda �� 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ńczyswoje istnienie.

W sytuacji tej nie istnieje klauzula ��, do której mogłaby zostać przekazana obsługawyjątku. Dlatego też, zanim wątek zakończy działanie, obsługa wyjątku zostaje przekazanado procedury obsługi wyjątków.

Procedura ta musi należeć do klasy, która implementuje interfejs �� 1��2�� . Interfejs ten składa się z pojedynczej metody

�� $� �#��,$� ��#��?��#��

Począwszy od JDK 5.0 metoda ��1��2�� pozwala nam zainstalowaćwłasną procedurę obsługi wyjątków dla dowolnego wątku. Metoda statyczna ��!�#��1��2�� należąca do klasy �� umożliwia zainstalowanie domyślnejprocedury obsługi wyjątków dla wszystkich wątków programu. Procedura taka może, naprzykład, używać interfejsu programowego dzienników do tworzenia raportów o wyjątkachnieobsłużonych.

Jeśli nie zainstalujemy domyślnej procedury obsługi wyjątków dla wszystkich wątków, tobędzie ona ��. Natomiast gdy nie zainstalujemy takiej procedury dla poszczególnychwątków, to procedura ta należeć będzie do obiektu �� , �� dla danego wątku.

Klasa �� , �� implementuje interfejs �� 1��2�� . Metoda �� 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�� grupy nadrzędnej.

2. W przeciwnym razie, jeśli metoda �� !�#��2�� zwracaprocedurę obsługi różną od ��, to zostaje ona wywołana.

3. W przeciwnym razie, gdy �� jest instancją �� !��, nie jestwykonywana żadna operacja.

4. W przeciwnym razie nazwa wątku i zrzut stosu dla �� zostają zapisanew . �� .

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 �� , ��i przesłonić jej metodę �� własną wersją.


��

� ��!�#��1��2�� 1��

2�� 5.0

� �� 1��2��

��!�#��1��2�� 5.0 konfiguruje lub pobiera domyślnąprocedurę obsługi wyjątków.

� ��1��2�� 1��2�� 5.0

� �� 1��2�� 1��2�� 5.0 konfigurujelub pobiera procedurę obsługi wyjątków. Jeśli żadna taka procedura nie zostanieskonfigurowana, to używana jest w tym celu grupa, do której należy wątek.

��

� �� -�� . Metodę tę definiujemy, abyuzyskać raport, gdy działanie wątku zostało zakończone na skutek nieobłużonegowyjątku.

Parametry: � wątek zakończony na skutek wyjątku, który nie zostałobsłużony,

� wyjątek, który nie został obsłużony.

��

� �� -�� . 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 grupanadrzędna nie istnieje, to wysyła zrzut stosu do standardowego strumienia błędów.(Jeśli � jest obiektem klasy �� !��, to informacja o zawartości stosu nie jestwysyłana. Obiekty klasy �� !�� generowane są przez metodę ��, której nienależy stosować).

java 2. techniki zaawansowane. wydanie ii

Technology