Tytuł oryginału: Java, A Beginner's Guide, 5th Edition
TÅ‚umaczenie: Jaromir Senczyk
ISBN: 978-83-246-3919-9
Original edition copyright © 2012 by The McGraw-Hill Companies, Inc.
All rights reserved.
Polish edition copyright © 2012 by HELION SA
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodÄ… kserograficznÄ…,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądz
towarowymi ich
właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane
z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie
ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji
zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. [phone]
e-mail: [e-mail]
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znalez
ć pod adresem:
ftp://ftp.helion.pl/przyklady/javpp5.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/javpp5
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
" Kup książkę " Księgarnia internetowa
" Poleć książkę " Lubię to! Nasza społeczność
" Oceń książkę
Spis tre ci
O autorze .................................................................................................11
O redaktorze technicznym ........................................................................11
Wst p ......................................................................................................13
Rozdzia 1. Podstawy Javy .........................................................................................19
Pochodzenie Javy ........................................................................................................................20
Java a j zyki C i C++ ............................................................................................................21
Java a C# ...............................................................................................................................22
Java a Internet ..............................................................................................................................22
Aplety Java ............................................................................................................................22
Bezpiecze stwo .....................................................................................................................23
Przeno no ...........................................................................................................................23
Magiczny kod bajtowy ................................................................................................................24
Terminologia Javy .......................................................................................................................25
Programowanie obiektowe ..........................................................................................................26
Hermetyzacja .........................................................................................................................27
Polimorfizm ...........................................................................................................................28
Dziedziczenie ........................................................................................................................28
Java Development Kit .................................................................................................................29
Pierwszy prosty program .............................................................................................................30
Wprowadzenie tekstu programu ............................................................................................30
Kompilowanie programu .......................................................................................................31
Pierwszy program wiersz po wierszu ....................................................................................31
Obs uga b dów sk adni ...............................................................................................................34
Drugi prosty program ..................................................................................................................35
Inne typy danych .........................................................................................................................37
Przyk ad 1.1. Zamiana galonów na litry ......................................................................................38
Dwie instrukcje steruj ce .............................................................................................................39
Instrukcja if ...........................................................................................................................40
P tla for .................................................................................................................................41
Bloki kodu ...................................................................................................................................43
rednik i pozycja kodu w wierszu ...............................................................................................44
Wci cia ........................................................................................................................................45
Przyk ad 1.2. Ulepszony konwerter galonów na litry ..................................................................45
S owa kluczowe j zyka Java .......................................................................................................46
Identyfikatory ..............................................................................................................................47
Biblioteki klas ..............................................................................................................................48
Test sprawdzaj cy .......................................................................................................................48
Poleć książkę
Kup książkę
4 Java. Przewodnik dla pocz tkuj cych
Rozdzia 2. Typy danych i operatory ............................................................................49
Dlaczego typy danych s tak wa ne ............................................................................................50
Typy podstawowe ........................................................................................................................50
Typy ca kowite ......................................................................................................................51
Typy zmiennoprzecinkowe ...................................................................................................52
Znaki .....................................................................................................................................53
Typ logiczny ................................................................................................................................54
Przyk ad 2.1. Jak daleko uderzy piorun? ....................................................................................55
Litera y ........................................................................................................................................56
Litera y szesnastkowe, ósemkowe i binarne ..........................................................................57
Specjalne sekwencje znaków ................................................................................................57
Litera y a cuchowe ..............................................................................................................58
Zmienne .......................................................................................................................................59
Inicjalizacja zmiennej ............................................................................................................59
Dynamiczna inicjalizacja ......................................................................................................60
Zasi g deklaracji i czas istnienia zmiennych ...............................................................................60
Operatory .....................................................................................................................................63
Operatory arytmetyczne ..............................................................................................................63
Inkrementacja i dekrementacja ..............................................................................................65
Operatory relacyjne i logiczne .....................................................................................................66
Warunkowe operatory logiczne ...................................................................................................67
Operator przypisania ....................................................................................................................69
Skrótowe operatory przypisania ..................................................................................................69
Konwersje typów w instrukcjach przypisania .............................................................................71
Rzutowanie typów niezgodnych ..................................................................................................72
Priorytet operatorów ....................................................................................................................74
Przyk ad 2.2. Tabela prawdy dla operatorów logicznych ............................................................74
Wyra enia ....................................................................................................................................75
Konwersja typów w wyra eniach ..........................................................................................76
Odst py i nawiasy .................................................................................................................77
Test sprawdzaj cy .......................................................................................................................78
Rozdzia 3. Instrukcje steruj ce .................................................................................79
Wprowadzanie znaków z klawiatury ...........................................................................................79
Instrukcja if ..................................................................................................................................81
Zagnie d anie instrukcji if ..........................................................................................................82
Drabinka if-else-if .......................................................................................................................83
Instrukcja switch ..........................................................................................................................84
Zagnie d anie instrukcji switch ...................................................................................................88
Przyk ad 3.1. Rozpoczynamy budow systemu pomocy .............................................................88
P tla for .......................................................................................................................................90
Wariacje na temat p tli for ..........................................................................................................92
Brakuj ce elementy .....................................................................................................................93
P tla niesko czona ................................................................................................................94
P tle bez cia a ..............................................................................................................................94
Deklaracja zmiennych steruj cych wewn trz p tli ......................................................................95
Rozszerzona p tla for ..................................................................................................................96
P tla while ...................................................................................................................................96
P tla do-while ..............................................................................................................................97
Przyk ad 3.2. Ulepszamy system pomocy ...................................................................................99
Przerywanie p tli instrukcj break .............................................................................................102
Zastosowanie break jako formy goto .........................................................................................104
Zastosowanie instrukcji continue ...............................................................................................108
Przyk ad 3.3. Ko cowa wersja systemu pomocy .......................................................................109
Poleć książkę
Kup książkę
Spis tre ci 5
P tle zagnie d one ....................................................................................................................112
Test sprawdzaj cy .....................................................................................................................113
Rozdzia 4. Wprowadzenie do klas, obiektów i metod ................................................115
Podstawy klas ............................................................................................................................116
Ogólna posta klasy ............................................................................................................116
Definiowanie klasy ..............................................................................................................117
Jak powstaj obiekty ..................................................................................................................120
Referencje obiektów i operacje przypisania ..............................................................................120
Metody ......................................................................................................................................121
Dodajemy metod do klasy Vehicle ....................................................................................122
Powrót z metody ........................................................................................................................124
Zwracanie warto ci ....................................................................................................................125
Stosowanie parametrów .............................................................................................................127
Dodajemy sparametryzowan metod do klasy Vehicle .....................................................128
Przyk ad 4.1. System pomocy jako klasa ...................................................................................130
Konstruktory ..............................................................................................................................135
Konstruktory z parametrami ......................................................................................................136
Dodajemy konstruktor do klasy Vehicle ....................................................................................137
Operator new .............................................................................................................................138
Odzyskiwanie nieu ytków i metoda finalize() ...........................................................................139
Metoda finalize() .......................................................................................................................139
Przyk ad 4.2. Ilustracja dzia ania odzyskiwania nieu ytków i metody finalize() ......................140
S owo kluczowe this ..................................................................................................................142
Test sprawdzaj cy .....................................................................................................................144
Rozdzia 5. Wi cej typów danych i operatorów ..........................................................145
Tablice .......................................................................................................................................145
Tablice jednowymiarowe ....................................................................................................146
Przyk ad 5.1. Sortowanie tablicy ...............................................................................................149
Tablice wielowymiarowe ..........................................................................................................151
Tablice dwuwymiarowe ......................................................................................................151
Tablice nieregularne ..................................................................................................................152
Tablice o trzech i wi cej wymiarach ...................................................................................153
Inicjalizacja tablic wielowymiarowych ...............................................................................153
Alternatywna sk adnia deklaracji tablic .....................................................................................155
Przypisywanie referencji tablic ..................................................................................................155
Wykorzystanie sk adowej length ...............................................................................................156
Przyk ad 5.2. Klasa Queue .........................................................................................................158
Styl for-each p tli for .................................................................................................................162
Iteracje w tablicach wielowymiarowych .............................................................................165
Zastosowania rozszerzonej p tli for ....................................................................................166
a cuchy znaków ......................................................................................................................167
Tworzenie a cuchów ..........................................................................................................167
Operacje na a cuchach .......................................................................................................168
Tablice a cuchów ...............................................................................................................170
a cuchy s niezmienne .....................................................................................................171
a cuchy steruj ce instrukcj switch ..................................................................................172
Wykorzystanie argumentów wywo ania programu ...................................................................173
Operatory bitowe .......................................................................................................................175
Operatory bitowe AND, OR, XOR i NOT ..........................................................................175
Operatory przesuni cia ........................................................................................................179
Skrótowe bitowe operatory przypisania ..............................................................................181
Przyk ad 5.3. Klasa ShowBits ...................................................................................................182
Poleć książkę
Kup książkę
6 Java. Przewodnik dla pocz tkuj cych
Operator ? ..................................................................................................................................184
Test sprawdzaj cy .....................................................................................................................186
Rozdzia 6. Wi cej o metodach i klasach ..................................................................189
Kontrola dost pu do sk adowych klasy .....................................................................................189
Modyfikatory dost pu w Javie ............................................................................................190
Przyk ad 6.1. Ulepszamy klas Queue .......................................................................................194
Przekazywanie obiektów metodom ...........................................................................................195
Sposób przekazywania argumentów ...................................................................................196
Zwracanie obiektów ..................................................................................................................199
Przeci anie metod ....................................................................................................................201
Przeci anie konstruktorów .......................................................................................................205
Przyk ad 6.2. Przeci amy konstruktor klasy Queue .................................................................207
Rekurencja .................................................................................................................................210
S owo kluczowe static ...............................................................................................................212
Bloki static ..........................................................................................................................215
Przyk ad 6.3. Algorytm Quicksort .............................................................................................216
Klasy zagnie d one i klasy wewn trzne ....................................................................................218
Zmienne liczby argumentów .....................................................................................................221
Metody o zmiennej liczbie argumentów ..............................................................................222
Przeci anie metod o zmiennej liczbie argumentów ...........................................................225
Zmienna liczba argumentów i niejednoznaczno ..............................................................226
Test sprawdzaj cy .....................................................................................................................227
Rozdzia 7. Dziedziczenie .........................................................................................229
Podstawy dziedziczenia .............................................................................................................230
Dost p do sk adowych a dziedziczenie ......................................................................................232
Konstruktory i dziedziczenie .....................................................................................................235
U ycie s owa kluczowego super do wywo ania konstruktora klasy bazowej ............................237
U ycie s owa kluczowego super do dost pu do sk adowych klasy bazowej .............................240
Przyk ad 7.1. Tworzymy hierarchi klas Vehicle ......................................................................241
Wielopoziomowe hierarchie klas ...............................................................................................244
Kiedy wywo ywane s konstruktory? ........................................................................................247
Referencje klasy bazowej i obiekty klasy pochodnej .................................................................248
Przes anianie metod ...................................................................................................................252
Przes anianie metod i polimorfizm ............................................................................................255
Po co przes ania metody? ........................................................................................................257
Zastosowanie przes aniania metod w klasie TwoDShape ...................................................257
Klasy abstrakcyjne .....................................................................................................................260
S owo kluczowe final ................................................................................................................264
final zapobiega przes anianiu ..............................................................................................264
final zapobiega dziedziczeniu ..............................................................................................265
U ycie final dla zmiennych sk adowych .............................................................................265
Klasa Object ..............................................................................................................................267
Test sprawdzaj cy .....................................................................................................................268
Rozdzia 8. Pakiety i interfejsy .................................................................................269
Pakiety .......................................................................................................................................269
Definiowanie pakietu ..........................................................................................................270
Wyszukiwanie pakietów i zmienna CLASSPATH ..............................................................271
Prosty przyk ad pakietu .......................................................................................................272
Pakiety i dost p do sk adowych .................................................................................................273
Przyk ad dost pu do pakietu ................................................................................................274
Sk adowe protected ...................................................................................................................275
Import pakietów .........................................................................................................................277
Poleć książkę
Kup książkę
Spis tre ci 7
Biblioteka klas Java u ywa pakietów ........................................................................................279
Interfejsy ....................................................................................................................................279
Implementacje interfejsów .........................................................................................................281
Referencje interfejsu ..................................................................................................................284
Przyk ad 8.1. Tworzymy interfejs Queue ..................................................................................286
Zmienne w interfejsach .............................................................................................................290
Interfejsy mog dziedziczy ......................................................................................................291
Test sprawdzaj cy .....................................................................................................................293
Rozdzia 9. Obs uga wyj tków ..................................................................................295
Hierarchia wyj tków ..................................................................................................................296
Podstawy obs ugi wyj tków ......................................................................................................296
S owa kluczowe try i catch ..................................................................................................297
Prosty przyk ad wyj tku ......................................................................................................298
Konsekwencje nieprzechwycenia wyj tku ................................................................................300
Wyj tki umo liwiaj obs ug b dów .................................................................................301
U ycie wielu klauzul catch ..................................................................................................302
Przechwytywanie wyj tków klas pochodnych ..........................................................................303
Zagnie d anie bloków try .........................................................................................................304
Generowanie wyj tku ................................................................................................................305
Powtórne generowanie wyj tku ..........................................................................................306
Klasa Throwable ........................................................................................................................307
Klauzula finally .........................................................................................................................309
U ycie klauzuli throws ..............................................................................................................311
Nowo ci w JDK 7 ......................................................................................................................312
Wyj tki wbudowane w Jav ......................................................................................................313
Tworzenie klas pochodnych wyj tków ......................................................................................315
Przyk ad 9.1. Wprowadzamy wyj tki w klasie Queue ...............................................................317
Test sprawdzaj cy .....................................................................................................................320
Rozdzia 10. Obs uga wej cia i wyj cia .......................................................................323
Strumienie wej cia i wyj cia .....................................................................................................324
Strumienie bajtowe i strumienie znakowe .................................................................................324
Klasy strumieni bajtowych ........................................................................................................325
Klasy strumieni znakowych .......................................................................................................326
Strumienie predefiniowane ........................................................................................................326
U ywanie strumieni bajtowych .................................................................................................327
Odczyt wej cia konsoli ........................................................................................................328
Zapis do wyj cia konsoli .....................................................................................................329
Odczyt i zapis plików za pomoc strumieni bajtowych .............................................................330
Odczyt z pliku .....................................................................................................................330
Zapis w pliku .......................................................................................................................334
Automatyczne zamykanie pliku .................................................................................................336
Odczyt i zapis danych binarnych ...............................................................................................339
Przyk ad 10.1. Narz dzie do porównywania plików .................................................................341
Pliki o dost pie swobodnym ......................................................................................................343
Strumienie znakowe ..................................................................................................................345
Odczyt konsoli za pomoc strumieni znakowych ................................................................345
Obs uga wyj cia konsoli za pomoc strumieni znakowych .................................................349
Obs uga plików za pomoc strumieni znakowych .....................................................................350
Klasa FileWriter ..................................................................................................................350
Klasa FileReader .................................................................................................................351
Zastosowanie klas opakowuj cych do konwersji a cuchów numerycznych ............................352
Przyk ad 10.2. System pomocy wykorzystuj cy pliki ...............................................................355
Test sprawdzaj cy .....................................................................................................................361
Poleć książkę
Kup książkę
8 Java. Przewodnik dla pocz tkuj cych
Rozdzia 11. Programowanie wielow tkowe ................................................................363
Podstawy wielow tkowo ci .......................................................................................................364
Klasa Thread i interfejs Runnable .............................................................................................365
Tworzenie w tku .......................................................................................................................365
Drobne usprawnienia ...........................................................................................................369
Przyk ad 11.1. Tworzymy klas pochodn klasy Thread ...........................................................370
Tworzenie wielu w tków ...........................................................................................................372
Jak ustali , kiedy w tek zako czy dzia anie? ...........................................................................375
Priorytety w tków .....................................................................................................................378
Synchronizacja ..........................................................................................................................380
Synchronizacja metod ................................................................................................................381
Synchronizacja instrukcji ..........................................................................................................384
Komunikacja mi dzyw tkowa ...................................................................................................386
Przyk ad u ycia metod wait() i notify() ...............................................................................387
Wstrzymywanie, wznawianie i ko czenie dzia ania w tków ....................................................392
Przyk ad 11.2. Wykorzystanie g ównego w tku ........................................................................396
Test sprawdzaj cy .....................................................................................................................397
Rozdzia 12. Typy wyliczeniowe, automatyczne opakowywanie,
import sk adowych statycznych i adnotacje .............................................399
Wyliczenia .................................................................................................................................400
Podstawy wylicze ..............................................................................................................400
Wyliczenia s klasami ...............................................................................................................403
Metody values() i valueOf() ......................................................................................................403
Konstruktory, metody, zmienne instancji a wyliczenia .............................................................404
Dwa wa ne ograniczenia .....................................................................................................406
Typy wyliczeniowe dziedzicz po klasie Enum ........................................................................406
Przyk ad 12.1. Komputerowo sterowana sygnalizacja wietlna ................................................408
Automatyczne opakowywanie ...................................................................................................413
Typy opakowuj ce .....................................................................................................................413
Podstawy automatycznego opakowywania ................................................................................415
Automatyczne opakowywanie i metody ....................................................................................416
Automatyczne opakowywanie i wyra enia ................................................................................418
Przestroga ............................................................................................................................419
Import sk adowych statycznych .................................................................................................420
Adnotacje (metadane) ................................................................................................................422
Test sprawdzaj cy .....................................................................................................................425
Rozdzia 13. Generyczno .........................................................................................427
Podstawy generyczno ci ............................................................................................................428
Prosty przyk ad generyczno ci ..................................................................................................428
Generyczno dotyczy tylko obiektów ................................................................................432
Typy generyczne ró ni si dla ró nych argumentów .........................................................432
Klasa generyczna o dwóch parametrach ..............................................................................433
Ogólna posta klasy generycznej ........................................................................................434
Ograniczanie typów ...................................................................................................................434
Stosowanie argumentów wieloznacznych .................................................................................438
Ograniczanie argumentów wieloznacznych ...............................................................................440
Metody generyczne ...................................................................................................................443
Konstruktory generyczne ...........................................................................................................445
Interfejsy generyczne .................................................................................................................445
Przyk ad 13.1. Generyczna klasa Queue ....................................................................................448
Typy surowe i tradycyjny kod ...................................................................................................452
Wnioskowanie typów i operator diamentowy ...........................................................................455
Wymazywanie ...........................................................................................................................456
Poleć książkę
Kup książkę
Spis tre ci 9
B dy niejednoznaczno ci .........................................................................................................457
Ograniczenia zwi zane z generyczno ci ..................................................................................458
Zakaz tworzenia instancji parametru okre laj cego typ ......................................................458
Ograniczenia dla sk adowych statycznych ..........................................................................458
Ograniczenia tablic generycznych .......................................................................................459
Ograniczenia zwi zane z wyj tkami ...................................................................................460
Dalsze studiowanie zagadnienia generyczno ci .........................................................................460
Test sprawdzaj cy .....................................................................................................................461
Rozdzia 14. Aplety, zdarzenia i pozosta e s owa kluczowe ..........................................463
Podstawy apletów ......................................................................................................................464
Organizacja apletów i podstawowe elementy ............................................................................467
Architektura apletu ....................................................................................................................467
Kompletny szkielet apletu .........................................................................................................468
Rozpocz cie i zako czenie dzia ania apletu ..............................................................................469
danie odrysowania .................................................................................................................470
Metoda update() ..................................................................................................................471
Przyk ad 14.1. Prosty aplet wy wietlaj cy baner .......................................................................471
Wykorzystanie okna statusu ......................................................................................................475
Parametry apletów .....................................................................................................................475
Klasa Applet ..............................................................................................................................477
Obs uga zdarze ........................................................................................................................479
Model delegacji zdarze ............................................................................................................479
Zdarzenia ...................................................................................................................................479
ród a zdarze .....................................................................................................................479
S uchacze zdarze ...............................................................................................................480
Klasy zdarze ......................................................................................................................480
Interfejsy s uchaczy zdarze ................................................................................................480
Wykorzystanie modelu delegacji zdarze ..................................................................................481
Obs uga zdarze myszy .......................................................................................................482
Prosty aplet obs uguj cy zdarzenia myszy ..........................................................................483
Inne s owa kluczowe Javy .........................................................................................................486
Modyfikatory transient i volatile .........................................................................................486
Operator instanceof .............................................................................................................486
S owo kluczowe strictfp ......................................................................................................487
S owo kluczowe assert ........................................................................................................487
Metody natywne ..................................................................................................................488
Test sprawdzaj cy .....................................................................................................................490
Rozdzia 15. Wprowadzenie do Swing .........................................................................491
Pochodzenie i filozofia Swing ...................................................................................................492
Komponenty i kontenery ...........................................................................................................494
Komponenty ........................................................................................................................494
Kontenery ............................................................................................................................495
Panele kontenerów szczytowych .........................................................................................495
Mened ery uk adu .....................................................................................................................496
Pierwszy program wykorzystuj cy Swing .................................................................................497
Pierwszy program Swing wiersz po wierszu .......................................................................498
Komponent JButton ...................................................................................................................502
Komponent JTextField ..............................................................................................................506
Komponent JCheckBox .............................................................................................................509
Komponent JList .......................................................................................................................512
Przyk ad 15.1. Porównywanie plików  aplikacja Swing ........................................................516
Wykorzystanie anonimowych klas wewn trznych do obs ugi zdarze .....................................521
Aplety Swing .............................................................................................................................522
Poleć książkę
Kup książkę
10 Java. Przewodnik dla pocz tkuj cych
Co dalej? ....................................................................................................................................524
Test sprawdzaj cy .....................................................................................................................525
Dodatek A Rozwi zania testów sprawdzaj cych .......................................................527
Rozdzia 1. Podstawy Javy ........................................................................................................527
Rozdzia 2. Typy danych i operatory .........................................................................................529
Rozdzia 3. Instrukcje steruj ce .................................................................................................531
Rozdzia 4. Wprowadzenie do klas, obiektów i metod ..............................................................533
Rozdzia 5. Wi cej typów danych i operatorów ........................................................................535
Rozdzia 6. Wi cej o metodach i klasach ..................................................................................538
Rozdzia 7. Dziedziczenie .........................................................................................................543
Rozdzia 8. Pakiety i interfejsy ..................................................................................................545
Rozdzia 9. Obs uga wyj tków ..................................................................................................546
Rozdzia 10. Obs uga wej cia i wyj cia .....................................................................................549
Rozdzia 11. Programowanie wielow tkowe .............................................................................552
Rozdzia 12. Typy wyliczeniowe, automatyczne opakowywanie,
import sk adowych statycznych i adnotacje ..........................................................554
Rozdzia 13. Generyczno .......................................................................................................558
Rozdzia 14. Aplety, zdarzenia i pozosta e s owa kluczowe ......................................................562
Rozdzia 15. Wprowadzenie do Swing ......................................................................................567
Dodatek B Komentarze dokumentacyjne ..................................................................573
Znaczniki javadoc ......................................................................................................................573
@author ...............................................................................................................................574
{@code} ..............................................................................................................................575
@deprecated ........................................................................................................................575
{@docRoot} ........................................................................................................................575
@exception .........................................................................................................................575
{@inheritDoc} ....................................................................................................................575
{@link} ...............................................................................................................................575
{@linkplain} .......................................................................................................................576
{@literal} ............................................................................................................................576
@param ...............................................................................................................................576
@return ...............................................................................................................................576
@see ....................................................................................................................................576
@serial ................................................................................................................................577
@serialData .........................................................................................................................577
@serialField ........................................................................................................................577
@since .................................................................................................................................577
@throws ..............................................................................................................................577
{@value} .............................................................................................................................578
@version .............................................................................................................................578
Ogólna posta komentarza dokumentacyjnego ..........................................................................578
Wynik dzia ania programu javadoc ...........................................................................................579
Przyk ad u ycia komentarzy dokumentacyjnych .......................................................................579
Skorowidz ..............................................................................................581
Poleć książkę
Kup książkę
Rozdzia 11.
Programowanie
wielow tkowe
W tym rozdziale poznasz:
podstawy wielow tkowo ci,
klas Thread i interfejs Runnable,
tworzenie w tku,
tworzenie wielu w tków,
sposób ustalania zako czenia w tku,
korzystanie z priorytetów w tków,
synchronizacj w tków,
synchronizacj metod,
synchronizacj bloków,
komunikacj mi dzyw tkow ,
wstrzymywanie, wznawianie i ko czenie dzia ania w tków.
Chocia Java dostarcza programistom wielu innowacyjnych mo liwo ci, to z pewno ci jedn
z najbardziej ekscytuj cych jest obs uga programowania wielow tkowego. Program wie-
low tkowy zawiera dwie lub wi cej cz ci, które mog dzia a równolegle. Ka d z tych
cz ci nazywamy w tkiem, a ka dy w tek definiuje osobn cie k wykonania. Wielow tko-
wo jest zatem szczególn form wielozadaniowo ci.
Poleć książkę
Kup książkę
364 Java. Przewodnik dla pocz tkuj cych
Podstawy wielow tkowo ci
Istniej dwa podstawowe typy wielozadaniowo ci, z których jeden opiera si na procesach,
a drugi wykorzystuje w tki. Wa ne jest, aby zrozumia ró nice mi dzy nimi. Proces odpo-
wiada w zasadzie wykonywanemu programowi. Zatem wielozadaniowo wykorzystuj ca
procesy umo liwia Twojemu komputerowi równoleg e wykonywanie dwóch lub wi cej pro-
gramów. Wykorzystanie procesów umo liwi Ci na przyk ad uruchomienie kompilatora Javy
w tym samym czasie, gdy piszesz kod ród owy w edytorze lub przegl dasz strony w Internecie.
W przypadku wielozadaniowo ci wykorzystuj cej procesy program jest najmniejsz jednostk
kodu podlegaj c szeregowaniu do wykonania przez procesor.
W drugim rodzaju wielozadaniowo ci najmniejsz jednostk kodu szeregowan przez system
jest w tek. Oznacza to, e pojedynczy program mo e równocze nie wykonywa dwa lub wi cej
w tków. Na przyk ad edytor tekstu mo e w tym samym czasie formatowa jeden tekst i dru-
kowa inny, pod warunkiem e obie akcje s wykonywane przez osobne w tki. Chocia Java
wykorzystuje rodowiska wielozadaniowe oparte na procesach, to nie umo liwia sterowania
ich dzia aniem. W przypadku w tków sprawy maj si inaczej.
Podstawow zalet wielow tkowo ci jest mo liwo tworzenia efektywnie dzia aj cych pro-
gramów, poniewa wielow tkowo pozwala wykorzysta okresy bezczynno ci pojawiaj ce
si w dzia aniu wi kszo ci programów. Wi kszo urz dze wej cia i wyj cia takich jak porty
sieciowe, nap dy dyskowe czy klawiatura dzia a znacznie wolniej od procesora. Z tego powodu
program cz sto sp dza wiele czasu na oczekiwaniu na mo liwo wys ania lub odebrania
danych za po rednictwem urz dzenia. Zastosowanie wielow tkowo ci pozwala programowi
wykonywa w tym czasie inne zadania. Na przyk ad w czasie gdy jedna cz programu wysy a
plik w Internecie, inna mo e zajmowa si odczytem klawiatury, a jeszcze inna buforowa
kolejny blok wysy anych danych.
W ostatnich kilku latach mamy do czynienia z upowszechnieniem si systemów wieloproce-
sorowych i wielordzeniowych. Oczywi cie nie wypar y one zupe nie systemów jednoproceso-
rowych. Wielow tkowo w Javie mo e dzia a w obu typach systemów. W przypadku sys-
temu jednordzeniowego wykonywane równolegle w tki wspó dziel procesor i ka dy w tek
otrzymuje pewien przedzia czasu procesora. Zatem w systemie jednordzeniowym dwa lub
wi cej w tków nie jest w rzeczywisto ci wykonywanych równocze nie, ale ich zastosowanie
pozwala wykorzysta czas bezczynno ci procesora. Natomiast w systemach wieloproceso-
rowych b d wielordzeniowych w tki rzeczywi cie mog dzia a równolegle. W wielu przy-
padkach pozwala to jeszcze bardziej poprawi efektywno dzia ania programu i zwi kszy
szybko wykonywania niektórych operacji.
W tek mo e znajdowa si w jednym z kilku stanów. Mo e by wykonywany. Mo e by
gotowy do wykonywania, gdy tylko otrzyma czas procesora. Wykonanie w tku mo e zosta
zawieszone, co oznacza, e w tek nie jest wykonywany przez pewien czas. Jego wykonywanie
mo e zosta pó niej podj te. W tek mo e zosta zablokowany w oczekiwaniu na zwolnienie
pewnego zasobu. I wreszcie wykonywanie w tku mo e zosta zako czone, co oznacza, e
nie mo na ju go podj .
Wielow tkowo wi e si nierozerwalnie z poj ciem synchronizacji, która umo liwia skoor-
dynowane dzia anie wielu w tków. Java dysponuje kompletnym podsystemem synchronizacji.
Jego podstawowe mo liwo ci równie omówi w tym rozdziale.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 365
Je li programowa e ju na przyk ad w systemie Windows, to by mo e masz pewne poj cie
o wielow tkowo ci. Java umo liwia zarz dzanie w tkami za pomoc odpowiednich elementów
j zyka, co czyni programowanie wielow tkowe szczególnie wygodnym, poniewa wiele jego
szczegó ów Java obs uguje za Ciebie.
Klasa Thread i interfejs Runnable
Wielow tkowo w Javie bazuje na klasie Thread i towarzysz cym jej interfejsie Runnable,
które umieszczono w pakiecie java.lang. Klasa Thread hermetyzuje w tek. Je li chcesz stwo-
rzy w programie nowy w tek, powiniene utworzy obiekt klasy pochodnej klasy Thread
albo zaimplementowa interfejs Runnable.
Klasa Thread definiuje szereg metod pomagaj cych zarz dza w tkami. Najcz ciej u ywane
z tych metod przedstawi em w tabeli 11.1 (przyjrzymy si im bli ej podczas ich u ycia
w przyk adach).
Tabela 11.1. Wybrane metody klasy Thread
Metoda Znaczenie
final String getName( ) Zwraca nazw w tku.
final int getPriority( ) Zwraca priorytet w tku.
final boolean isAlive( ) Sprawdza, czy w tek jest nadal wykonywany.
final void join( ) Czeka na zako czenie w tku.
void run( ) Punkt wej cia w tku.
static void sleep(long milisekund) Zawiesza wykonywanie w tku na podan liczb milisekund.
void start( ) Rozpoczyna wykonywanie w tku przez wywo anie metody run( ).
Wszystkie procesy maj przynajmniej jeden w tek wykonania, zwykle nazywany w tkiem
g ównym, poniewa jego wykonanie rozpoczyna si w momencie uruchomienia programu.
Mo emy zatem powiedzie , e we wszystkich dotychczasowych przyk adach u ywali my
w tku g ównego. W w tku g ównym mo esz tworzy kolejne w tki programu.
Tworzenie w tku
W tek powstaje przez utworzenie obiektu typu Thread. Klasa Thread hermetyzuje obiekt, który
mo e by wykonywany. Jak ju wspomnia em, Java umo liwia dwa sposoby tworzenia takich
obiektów:
poprzez implementacj interfejsu Runnable,
poprzez tworzenie klas pochodnych klasy Thread.
W wi kszo ci przyk adów w tym rozdziale b dziemy implementowa interfejs Runnable.
Natomiast w przyk adzie 11.1 zademonstruj , jak zaimplementowa w tek, tworz c klas
Poleć książkę
Kup książkę
366 Java. Przewodnik dla pocz tkuj cych
pochodn klasy Thread. Zapami taj: oba podej cia i tak u ywaj klasy Thread do tworzenia
w tku i zarz dzania nim. Jedyna ró nica polega na sposobie, w jaki powstaje klasa reprezentu-
j ca w tki.
Interfejs Runnable stanowi abstrakcj wykonywalnego kodu. W tek mo esz utworzy na
podstawie ka dego obiektu, który implementuje interfejs Runnable. Interfejs ten ma tylko jedn
metod o nazwie run() zadeklarowan w nast puj cy sposób:
public void run()
Wewn trz metody run() umieszczasz kod wykonywany przez nowy w tek. Podobnie jak
g ówny w tek programu, tak i metoda run()mo e wywo ywa inne metody, u ywa innych
klas i deklarowa zmienne. Jedyna ró nica polega na tym, e metoda run() jest punktem
wej cia do osobnego, równolegle wykonywanego w tku programu. Wykonywanie tego w tku
ko czy si , gdy metoda run() zwróci sterowanie.
Po utworzeniu klasy implementuj cej interfejs Runnable na podstawie jej obiektu tworzysz
obiekt typu Thread. Klasa Thread definiuje szereg konstruktorów. Na pocz tek b dziemy
u ywa poni szego:
Thread(Runnable obW tku)
W tym przypadku parametr obW tku jest instancj klasy implementuj cej interfejs Runnable.
Definiuje on punkt, w którym rozpocznie si wykonywanie nowego w tku.
Po utworzeniu nowy w tek nie b dzie wykonywany, dopóki nie wywo asz jego metody
start() zadeklarowanej w klasie Thread. Dzia anie metody start() sprowadza si w zasadzie
do wywo ania metody run(). Poni ej przedstawi em deklaracj metody start():
void start()
Na listingu 11.1 przedstawi em przyk ad programu, który tworzy nowy w tek i rozpoczyna
jego wykonywanie.
Listing 11.1. UseThreads.java
// Tworzy w tek, implementuj c interfejs Runnable.
Obiekty klasy MyThread mog by
wykonywane we w asnych w tkach,
class MyThread implements Runnable {
poniewa klasa MyThread implementuje
String thrdName;
interfejs Runnable.
MyThread(String name) {
thrdName = name;
}
// Punkt wej ciowy w tku.
public void run() { Tutaj rozpoczyna si wykonywanie w tku.
System.out.println(thrdName + " rozpoczyna dzia anie.");
try {
for(int count=0; count < 10; count++) {
Thread.sleep(400);
System.out.println(thrdName +
" jest wykonywany, warto licznika: " + count);
}
}
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 367
catch(InterruptedException exc) {
System.out.println(thrdName + " zosta przerwany.");
}
System.out.println(thrdName + " ko czy dzia anie.");
}
}
class UseThreads {
public static void main(String args[]) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
// Najpierw tworzy obiekt klasy MyThread.
Tworzy obiekt
MyThread mt = new MyThread("W tek potomny nr 1"); implementuj cy
interfejs Runnable.
// Nast pnie na jego podstawie tworzy w tek.
Thread newThrd = new Thread(mt); Tworzy w tek dla tego obiektu.
// Na koniec rozpoczyna wykonywanie w tku.
newThrd.start(); Uruchamia w tek.
for(int i=0; i<50; i++) {
System.out.print(".");
try {
Thread.sleep(100);
}
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
Przyjrzyjmy si bli ej temu programowi. Najpierw klasa MyThread implementuje interfejs
Runnable. Oznacza to, e obiekt typu MyThread mo e zosta przekazany konstruktorowi klasy
i by wykonywany we w asnym w tku.
Wewn trz metody run() dzia a p tla for odliczaj ca od 0 do 9. Zwró uwag na wywo anie
metody sleep(). Metoda sleep() powoduje zawieszenie w tku, w którym zosta a wywo ana,
na czas wyra ony w milisekundach. Jej deklaracj przedstawi em poni ej:
static void sleep(long milisekund) throwws InterruptedException
Wykonywanie w tku zostaje zawieszone na czas milisekund. Metoda sleep() mo e wygene-
rowa wyj tek InterruptedException i wobec tego musi by wywo ywana w bloku try.
Metoda sleep() ma równie drug wersj , która umo liwia okre lenie czasu zawieszenia
w tku z dok adno ci nie tylko co do milisekundy, ale równie nanosekundy, je li potrzebu-
jesz a takiej precyzji. W naszym przyk adzie metoda sleep() wywo ywana przez metod
run() zawiesza wykonywanie w tku na 400 milisekund podczas ka dego przebiegu p tli.
Dzi ki temu spowolnieniu mo emy obserwowa wykonywanie w tku.
Wewn trz metody main() nowy obiekt typu Thread zostaje utworzony na skutek wykonania
poni szej sekwencji instrukcji:
Poleć książkę
Kup książkę
368 Java. Przewodnik dla pocz tkuj cych
// Najpierw tworzy obiekt klasy MyThread.
MyThread mt = new MyThread("W tek potomny nr 1");
// Nast pnie na jego podstawie tworzy w tek.
Thread newThrd = new Thread(mt);
// Na koniec rozpoczyna wykonywanie w tku.
newThrd.start();
Jak sugeruj to komentarze, najpierw zostaje utworzony obiekt klasy MyThread. Obiekt ten
zostaje nast pnie u yty do stworzenia obiektu typu Thread. Jest to mo liwe, poniewa klasa
MyThread implementuje interfejs Runnable. Na koniec wykonywanie nowego w tku rozpo-
czyna si dzi ki wywo aniu metody start(). Wywo uje ona metod run() nowego w tku.
Po wywo aniu metody start() sterowanie powraca do metody main(), która rozpoczyna
wykonywanie w asnej p tli for. P tla ta wykonywana jest 50 razy i w ka dym przebiegu zawie-
sza wykonanie g ównego w tku na 100 milisekund. Oba w tki kontynuuj swoje dzia anie,
wspó dziel c procesor (w systemie jednoprocesorowym). Trwa to a do momentu, w którym
zako czy si dzia anie wykonywanych przez nie p tli. Komunikaty wy wietlane przez oba
w tki przedstawi em poni ej. Ze wzgl du na ró nice w rodowisku wykonania programu
efekt jego dzia ania w Twoim przypadku mo e si nieco ró ni .
G ówny w tek rozpoczyna dzia anie.
.W tek potomny nr 1 rozpoczyna dzia anie.
....W tek potomny nr 1 jest wykonywany, warto licznika: 0
...W tek potomny nr 1 jest wykonywany, warto licznika: 1
....W tek potomny nr 1 jest wykonywany, warto licznika: 2
....W tek potomny nr 1 jest wykonywany, warto licznika: 3
....W tek potomny nr 1 jest wykonywany, warto licznika: 4
....W tek potomny nr 1 jest wykonywany, warto licznika: 5
....W tek potomny nr 1 jest wykonywany, warto licznika: 6
....W tek potomny nr 1 jest wykonywany, warto licznika: 7
....W tek potomny nr 1 jest wykonywany, warto licznika: 8
....W tek potomny nr 1 jest wykonywany, warto licznika: 9
W tek potomny nr 1 ko czy dzia anie.
..........W tek g ówny ko czy dzia anie.
W przyk adzie tym warto zwróci uwag na jeszcze jedn rzecz. Aby zilustrowa fakt rów-
noczesnego wykonywania w tku g ównego i w tku mt, musia em unikn zako czenia dzia-
ania metody main(), zanim w tek mt zako czy swoje dzia anie. W tym celu wykorzysta em
ró nice czasowe w dzia aniu obu w tków. Poniewa wywo ania metody sleep() w p tli for
metody main() powoduj ca kowite opó nienie równe 5 sekund (50 iteracji po 100 sekund
ka da), a ca kowite opó nienie wewn trz p tli for metody run() wynosi jedynie 4 sekundy
(10 iteracji po 400 milisekund ka da), metoda run() zako czy dzia anie sekund wcze niej
ni metoda main(). W efekcie w tek g ówny i w tek mt s wykonywane równolegle do momentu
zako czenia w tku mt. Wykonywanie w tku g ównego (metody main()) ko czy si sekund
pó niej.
Chocia wykorzystanie ró nic czasowych pozwoli o mi zademonstrowa równoleg e dzia a-
nie w tków, rozwi zania takiego nie stosuje si w praktyce. Java udost pnia znacznie lepsze
sposoby oczekiwania na zako czenie w tku. Jeden z nich omówi w dalszej cz ci rozdzia u.
I jeszcze jedno: w przypadku programów wielow tkowych najcz ciej b dziemy chcieli, aby
w tek g ówny ko czy swoje dzia anie jako ostatni. W ogólnym przypadku program dzia a,
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 369
dopóki nie zako czy si wykonywanie wszystkich jego w tków. Zatem nie jest wymagane,
by w tek g ówny ko czy swoje dzia anie jako ostatni. Ale cz sto jest to przyk adem dobrej
praktyki programistycznej, zw aszcza gdy dopiero uczysz si korzystania z w tków.
Drobne usprawnienia
Chocia poprzedni program jest zupe nie poprawny, niewielkie modyfikacje mog usprawni
jego dzia anie i u atwi jego u ycie. Po pierwsze, mo emy rozpocz wykonywanie w tku
natychmiast po jego utworzeniu. W tym celu tworzymy obiekt Thread wewn trz konstruktora
klasy MyThread. Po drugie, klasa MyThread nie musi przechowywa nazwy w tku, poniewa
mo emy nada mu j podczas tworzenia. W tym celu u yjemy nast puj cej wersji konstruktora
klasy Thread:
Thread(Runnable obW tku, String nazwa)
W tym przypadku parametr nazwa okre la oczywi cie nazw w tku.
Ekspert odpowiada
Pytanie: Dlaczego zalecasz, aby g ówny w tek ko czy dzia anie jako ostatni?
Odpowied : W starszych wersjach Javy zako czenie dzia ania g ównego w tku przed zako czeniem
dzia ania w tku potomnego mog o powodowa b d dzia ania maszyny wirtualnej. Nowoczesne wersje
Javy nie stwarzaj ju tego rodzaju problemów. Lepiej jednak zachowa ostro no , poniewa nigdy
nie wiemy, w jakim rodowisku przyjdzie dzia a naszemu programowi. Dodatkowo w tek g ówny
jest doskona ym miejscem do wykonania operacji zwi zanych z zako czeniem dzia ania programu,
na przyk ad zamkni cia plików. Z tego powodu cz sto rzeczywi cie ma sens, aby ko czy on swoje
dzia anie jako ostatni. Na szcz cie bardzo atwo mo emy zaprogramowa oczekiwanie w tku g ów-
nego na zako czenie dzia ania wszystkich jego w tków potomnych.
Nazw w tku mo emy uzyska , wywo uj c metod getName() zdefiniowan w klasie Thread.
Jej ogóln posta przedstawi em poni ej:
final String getName()
Chocia nie jest to konieczne, w naszym nast pnym programie mo esz nada nazw w tkowi
po jego utworzeniu. W tym celu u yjesz metody setName() przedstawionej poni ej:
final void setName(String nazwaW tku)
Ulepszon wersj poprzedniego programu przedstawi em na listingu 11.2.
Listing 11.2. UseThreadsImproved.java
// Ulepszona wersja klasy MyThread.
class MyThread implements Runnable {
Thread thrd; Zmienna thrd przechowuje referencj w tku.
// Tworzy nowy w tek.
MyThread(String name) {
thrd = new Thread(this, name); W tek otrzymuje nazw w momencie utworzenia.
thrd.start(); // uruchamia nowy w tek Uruchamia w tek.
Poleć książkę
Kup książkę
370 Java. Przewodnik dla pocz tkuj cych
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
try {
for(int count=0; count<10; count++) {
Thread.sleep(400);
System.out.println(thrd.getName() +
" jest wykonywany, warto licznika: " + count);
}
}
catch(InterruptedException exc) {
System.out.println(thrd.getName() + " zosta przerwany.");
}
System.out.println(thrd.getName() + " ko czy dzia anie.");
}
}
class UseThreadsImproved {
public static void main(String args[]) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
MyThread mt = new MyThread("W tek potomny nr 1");
for(int i=0; i < 50; i++) { Teraz w tek zostaje uruchomiony w momencie utworzenia.
System.out.print(".");
try {
Thread.sleep(100);
}
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
Ta wersja programu wy wietla takie same komunikaty jak poprzednia. Zwró uwag , e refe-
rencj w tku przechowuje sk adowa thrd klasy MyThread.
Przyk ad 11.1. Tworzymy klas pochodn klasy Thread
Implementacja interfejsu Runnable jest jednym ze sposobów tworzenia klasy
ExtendThread.java
reprezentuj cej w tki. Drugi sposób polega na utworzeniu klasy w tków jako
klasy pochodnej klasy Thread. W tym przyk adzie utworzymy w a nie klas pochodn klasy
Thread i wykorzystamy j w programie, którego funkcjonalno b dzie odpowiada progra-
mowi UseThreadsImproved.
Tworz c klas pochodn klasy Thread, musimy przes oni jej metod run() stanowi c punkt
wej cia do nowego w tku. Nowa klasa musi równie wywo a metod start(), aby rozpo-
cz wykonywanie nowego w tku. Mo esz równie przes oni inne metody klasy Thread(), ale
nie jest to wymagane.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 371
1. Utwórz plik o nazwie ExtendThread.java. Skopiuj do niego kod ród owy z pliku
UseThreadsImproved.java.
2. Zmie deklaracj klasy Thread tak, aby zamiast implementowa interfejs Runnable,
dziedziczy a po klasie Thread:
class MyThread extends Thread {
3. Usu poni szy wiersz:
Thread thrd;
Zmienna sk adowa thrd nie jest ju potrzebna, poniewa instancja klasy MyThread
zawiera instancj klasy Thread, do której mo e si odwo ywa .
4. Zmie konstruktor klasy MyThread w nast puj cy sposób:
// Tworzy nowy w tek.
MyThread(String name) {
super(name); // nazwa w tku
start(); // uruchamia w tek
}
Wywo anie super zostaje u yte w celu uruchomienia nast puj cego konstruktora
klasy Thread:
Thread(String nazwa)
gdzie parametr nazwa okre la oczywi cie nazw tworzonego w tku.
5. Zmie metod run() tak, aby bezpo rednio, czyli bez u ycia zmiennej thrd, wywo ywa a
metod getName():
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
System.out.println(getName() + " rozpoczyna dzia anie.");
try {
for(int count=0; count < 10; count++) {
Thread.sleep(400);
System.out.println(getName() +
" jest wykonywany, warto licznika: " + count);
}
}
catch(InterruptedException exc) {
System.out.println(getName() + " zosta przerwany.");
}
System.out.println(getName() + " zosta przerwany.");
}
6. Na listingu 11.3 przedstawi em kompletny tekst ród owy programu, który w obecnej
wersji tworzy klas pochodn klasy Thread, zamiast implementowa interfejs Runnable.
Wynik dzia ania wy wietlany przez program b dzie taki sam jak w przypadku
poprzednich wersji programu.
Listing 11.3. ExtendThread.java
/*
Przyk ad 11.1
Tworzy klas pochodn klasy Thread.
Poleć książkę
Kup książkę
372 Java. Przewodnik dla pocz tkuj cych
*/
class MyThread extends Thread {
// Tworzy nowy w tek.
MyThread(String name) {
super(name); // nazwa w tku
start(); // uruchamia w tek
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
System.out.println(getName() + " rozpoczyna dzia anie.");
try {
for(int count=0; count < 10; count++) {
Thread.sleep(400);
System.out.println(getName() +
" jest wykonywany, warto licznika: " + count);
}
}
catch(InterruptedException exc) {
System.out.println(getName() + " zosta przerwany.");
}
System.out.println(getName() + " zosta przerwany.");
}
}
class ExtendThread {
public static void main(String args[]) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
MyThread mt = new MyThread("W tek potomny nr 1");
for(int i=0; i < 50; i++) {
System.out.print(".");
try {
Thread.sleep(100);
}
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
Tworzenie wielu w tków
W poprzednich przyk adach tworzyli my tylko jeden w tek potomny. Nic nie stoi jednak na
przeszkodzie, aby Twój program tworzy dowoln , potrzebn liczb w tków. Program przed-
stawiony na listingu 11.4 tworzy trzy w tki potomne.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 373
Listing 11.4. MoreThreads.java
// Tworzy wiele w tków.
class MyThread implements Runnable {
Thread thrd;
// Tworzy nowy w tek.
MyThread(String name) {
thrd = new Thread(this, name);
thrd.start(); // uruchamia w tek
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
try {
for(int count=0; count < 10; count++) {
Thread.sleep(400);
System.out.println(thrd.getName() +
" jest wykonywany, warto licznika: " + count);
}
}
catch(InterruptedException exc) {
System.out.println(thrd.getName() + " zosta przerwany.");
}
System.out.println(thrd.getName() + " ko czy dzia anie.");
}
}
class MoreThreads {
public static void main(String args[]) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
MyThread mt1 = new MyThread("W tek potomny nr 1");
Tworzy i uruchamia
MyThread mt2 = new MyThread("W tek potomny nr 2");
trzy w tki.
MyThread mt3 = new MyThread("W tek potomny nr 3");
for(int i=0; i < 50; i++) {
System.out.print(".");
try {
Thread.sleep(100);
}
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
A oto przyk ad dzia ania tego programu:
G ówny w tek rozpoczyna dzia anie.
W tek potomny nr 1 rozpoczyna dzia anie.
Poleć książkę
Kup książkę
374 Java. Przewodnik dla pocz tkuj cych
W tek potomny nr 3 rozpoczyna dzia anie.
.W tek potomny nr 2 rozpoczyna dzia anie.
...W tek potomny nr 1 jest wykonywany, warto licznika: 0
W tek potomny nr 3 jest wykonywany, warto licznika: 0
.W tek potomny nr 2 jest wykonywany, warto licznika: 0
...W tek potomny nr 1 jest wykonywany, warto licznika: 1
W tek potomny nr 3 jest wykonywany, warto licznika: 1
.W tek potomny nr 2 jest wykonywany, warto licznika: 1
...W tek potomny nr 1 jest wykonywany, warto licznika: 2
W tek potomny nr 3 jest wykonywany, warto licznika: 2
.W tek potomny nr 2 jest wykonywany, warto licznika: 2
....W tek potomny nr 3 jest wykonywany, warto licznika: 3
W tek potomny nr 1 jest wykonywany, warto licznika: 3
W tek potomny nr 2 jest wykonywany, warto licznika: 3
....W tek potomny nr 3 jest wykonywany, warto licznika: 4
W tek potomny nr 1 jest wykonywany, warto licznika: 4
W tek potomny nr 2 jest wykonywany, warto licznika: 4
....W tek potomny nr 3 jest wykonywany, warto licznika: 5
W tek potomny nr 1 jest wykonywany, warto licznika: 5
W tek potomny nr 2 jest wykonywany, warto licznika: 5
...W tek potomny nr 3 jest wykonywany, warto licznika: 6
W tek potomny nr 1 jest wykonywany, warto licznika: 6
.W tek potomny nr 2 jest wykonywany, warto licznika: 6
...W tek potomny nr 3 jest wykonywany, warto licznika: 7
W tek potomny nr 1 jest wykonywany, warto licznika: 7
.W tek potomny nr 2 jest wykonywany, warto licznika: 7
...W tek potomny nr 1 jest wykonywany, warto licznika: 8
.W tek potomny nr 3 jest wykonywany, warto licznika: 8
W tek potomny nr 2 jest wykonywany, warto licznika: 8
...W tek potomny nr 1 jest wykonywany, warto licznika: 9
W tek potomny nr 1 ko czy dzia anie.
.W tek potomny nr 3 jest wykonywany, warto licznika: 9
W tek potomny nr 3 ko czy dzia anie.
W tek potomny nr 2 jest wykonywany, warto licznika: 9
W tek potomny nr 2 ko czy dzia anie.
.........W tek g ówny ko czy dzia anie.
Ekspert odpowiada
Pytanie: Dlaczego Java udost pnia dwa sposoby tworzenia w tków potomnych (przez tworzenie klas
pochodnych klasy Thread lub przez implementacj interfejsu Runnable) i który z nich jest lepszy?
Odpowied : Klasa Thread definiuje szereg metod, które mog zosta przes oni te w klasie pochod-
nej. Natomiast wymagane jest przes oni cie tylko jednej z nich: run(). Ta sama metoda jest oczy-
wi cie wymagana podczas implementacji interfejsu Runnable. Cz programistów Javy uwa a, e
klasy pochodne nale y tworzy tylko wtedy, gdy stanowi one specjalizacj klasy bazowej. Je li zatem
nie zamierzasz przes ania adnej innej metody klasy Thread, to najlepiej implementuj interfejs
Runnable. Implementacja interfejsu klasy Runnable umo liwi Twojej klasie w tku równie dziedzicze-
nie po innej klasie ni klasa Thread.
Jak widzisz, po uruchomieniu wszystkie trzy w tki potomne wspó dziel czas procesora. Zwró
uwag , e w tki s uruchamiane w kolejno ci ich utworzenia. Nie jest to regu , Java mo e usze-
regowa dzia anie w tków w dowolny sposób. Ze wzgl du na ró nice w rodowisku wyko-
nywania informacje wy wietlane przez program mog si nieco ró ni w Twoim przypadku.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 375
Jak ustali , kiedy w tek
zako czy dzia anie?
Cz sto w programie chcieliby my sprawdzi , czy w tek zako czy swoje dzia anie. Na przy-
k ad w poprzednich przyk adach w celach demonstracyjnych nie chcia em ko czy dzia ania
g ównego w tku, zanim nie zako czy y si w tki potomne. W tym celu zawiesza em dzia a-
nie w tku g ównego na d u ej ni w tków potomnych. Jednak w ogólnym przypadku trudno
uzna takie rozwi zanie za satysfakcjonuj ce.
Na szcz cie klasa Thread dostarcza dwóch sposobów pozwalaj cych ustali , czy w tek zako -
czy dzia anie. Pierwszy z nich polega na wywo aniu metody isAlive() dla sprawdzanego
w tku. Ogóln posta tej metody przedstawi em poni ej:
final boolean isAlive()
Metoda isAlive() zwraca warto true, je li wyj tek, dla którego zosta a wywo ana, nadal
dzia a. W przeciwnym razie zwraca warto false. Aby wypróbowa jej dzia anie, zast p
w poprzednim przyk adzie klas MoreThreads jej wersj przedstawion na listingu 11.5.
Listing 11.5. MoreThreads2.java
// U ywa isAlive().
class MoreThreads2 {
public static void main(String args[]) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
MyThread mt1 = new MyThread("W tek potomny nr 1");
MyThread mt2 = new MyThread("W tek potomny nr 2");
MyThread mt3 = new MyThread("W tek potomny nr 3");
do {
System.out.print(".");
try {
Thread.sleep(100);
}
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
} while (mt1.thrd.isAlive() ||
mt2.thrd.isAlive() || Oczekuje na zako czenie wszystkich w tków.
mt3.thrd.isAlive());
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
Ta wersja programu wy wietla podobne informacje jak poprzednia, z t ró nic , e metoda
main() ko czy swoje dzia anie, jak tylko zako cz je pozosta e w tki. Ró nica ta wynika
z zastosowania metody isAlive() podczas oczekiwania na zako czenie w tków potomnych.
Drugi sposób oczekiwania na zako czenie w tku polega na wywo aniu metody join() przed-
stawionej poni ej:
Poleć książkę
Kup książkę
376 Java. Przewodnik dla pocz tkuj cych
final void join( ) throws InterruptedException
Metoda ta czeka, a w tek, dla którego zosta a wywo ana, zako czy dzia anie. Nazwa metody
sugeruje, e w tek, który j wywo a , czeka, a okre lony w tek si z nim po czy (ang. join).
Inne wersje metody join() pozwalaj okre li maksymalny czas oczekiwania na zako cze-
nie w tku.
Na listingu 11.6 przedstawi em program, który u ywa metody join(), aby zagwarantowa ,
e g ówny w tek zako czy swoje dzia anie jako ostatni.
Listing 11.6. JoinThreads.java
// U ywa join().
class MyThread implements Runnable {
Thread thrd;
// Tworzy nowy w tek.
MyThread(String name) {
thrd = new Thread(this, name);
thrd.start(); // uruchamia nowy w tek
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
try {
for(int count=0; count < 10; count++) {
Thread.sleep(400);
System.out.println(thrd.getName() +
" jest wykonywany, warto licznika: " + count);
}
}
catch(InterruptedException exc) {
System.out.println(thrd.getName() + " zosta przerwany.");
}
System.out.println(thrd.getName() + " ko czy dzia anie.");
}
}
class JoinThreads {
public static void main(String args[]) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
MyThread mt1 = new MyThread("W tek potomny nr 1");
MyThread mt2 = new MyThread("W tek potomny nr 2");
MyThread mt3 = new MyThread("W tek potomny nr 3");
try {
mt1.thrd.join();
System.out.println("W tek potomny nr 1 zako czy dzia anie.");
Oczekuj na zako czenie
mt2.thrd.join();
konkretnego w tku.
System.out.println("W tek potomny nr 2 zako czy dzia anie.");
mt3.thrd.join();
System.out.println("W tek potomny nr 3 zako czy dzia anie.");
}
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 377
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
Poni ej przedstawi em wynik dzia ania tego programu. Pami taj, e gdy uruchomisz program
w swoim rodowisku, wynik mo e by nieco inny.
G ówny w tek rozpoczyna dzia anie.
W tek potomny nr 1 rozpoczyna dzia anie.
W tek potomny nr 3 rozpoczyna dzia anie.
W tek potomny nr 2 rozpoczyna dzia anie.
W tek potomny nr 1 jest wykonywany, warto licznika: 0
W tek potomny nr 2 jest wykonywany, warto licznika: 0
W tek potomny nr 3 jest wykonywany, warto licznika: 0
W tek potomny nr 1 jest wykonywany, warto licznika: 1
W tek potomny nr 2 jest wykonywany, warto licznika: 1
W tek potomny nr 3 jest wykonywany, warto licznika: 1
W tek potomny nr 1 jest wykonywany, warto licznika: 2
W tek potomny nr 2 jest wykonywany, warto licznika: 2
W tek potomny nr 3 jest wykonywany, warto licznika: 2
W tek potomny nr 2 jest wykonywany, warto licznika: 3
W tek potomny nr 1 jest wykonywany, warto licznika: 3
W tek potomny nr 3 jest wykonywany, warto licznika: 3
W tek potomny nr 1 jest wykonywany, warto licznika: 4
W tek potomny nr 2 jest wykonywany, warto licznika: 4
W tek potomny nr 3 jest wykonywany, warto licznika: 4
W tek potomny nr 2 jest wykonywany, warto licznika: 5
W tek potomny nr 1 jest wykonywany, warto licznika: 5
W tek potomny nr 3 jest wykonywany, warto licznika: 5
W tek potomny nr 1 jest wykonywany, warto licznika: 6
W tek potomny nr 2 jest wykonywany, warto licznika: 6
W tek potomny nr 3 jest wykonywany, warto licznika: 6
W tek potomny nr 1 jest wykonywany, warto licznika: 7
W tek potomny nr 2 jest wykonywany, warto licznika: 7
W tek potomny nr 3 jest wykonywany, warto licznika: 7
W tek potomny nr 2 jest wykonywany, warto licznika: 8
W tek potomny nr 1 jest wykonywany, warto licznika: 8
W tek potomny nr 3 jest wykonywany, warto licznika: 8
W tek potomny nr 2 jest wykonywany, warto licznika: 9
W tek potomny nr 1 jest wykonywany, warto licznika: 9
W tek potomny nr 2 ko czy dzia anie.
W tek potomny nr 1 ko czy dzia anie.
W tek potomny nr 1 zako czy dzia anie.
W tek potomny nr 2 zako czy dzia anie.
W tek potomny nr 3 jest wykonywany, warto licznika: 9
W tek potomny nr 3 ko czy dzia anie.
W tek potomny nr 3 zako czy dzia anie.
W tek g ówny ko czy dzia anie.
Jak atwo zauwa y , powrót sterowania z metody join() oznacza zako czenie w tku.
Poleć książkę
Kup książkę
378 Java. Przewodnik dla pocz tkuj cych
Priorytety w tków
Z ka dym w tkiem zwi zany jest priorytet. Priorytet w tku decyduje, przynajmniej cz ciowo,
o tym, ile czasu procesora otrzyma dany w tek w porównaniu do innych w tków. W ogólnym
przypadku spodziewamy si , e w tek o niskim priorytecie otrzyma ma o czasu procesora,
a w tek o wysokim priorytecie znacznie wi cej. Ilo czasu procesora przydzielonego w tkowi
ma istotny wp yw na charakterystyk wykonania w tku i jego interakcj z innymi w tkami
wykonywanymi równolegle w systemie.
Na ilo czasu procesora przydzielan w tkowi maj wp yw oprócz priorytetu w tku tak e
inne czynniki. Na przyk ad: je li w tek o wysokim priorytecie oczekuje na pewien zasób, na
przyk ad na wprowadzenie danych z klawiatury, to w tym czasie wykonywane b d w tki o ni -
szym priorytecie. Jednak gdy w tek o wysokim priorytecie uzyska dost p do zasobu, to w tki
o ni szym priorytecie zostan wyw aszczone z procesora i wznowione zostanie wykonywa-
nie w tku o wysokim priorytecie. Innym czynnikiem wp ywaj cym na szeregowanie w tków
jest sposób implementacji wielozadaniowo ci w danym systemie (patrz ramka  Ekspert odpo-
wiada na ko cu tego podrozdzia u). Dlatego te nawet je li nadasz ró ne priorytety w tkom
programu, nie musi to oznacza , e jeden z w tków b dzie wykonywany szybciej lub cz ciej
ni inny w tek. W tek o wysokim priorytecie ma jedynie potencjalnie lepszy dost p do pro-
cesora.
W tek potomny ma po uruchomieniu taki sam priorytet jak w tek g ówny. Priorytet w tku
mo esz zmieni za pomoc metody setPriority() zdefiniowanej w klasie Thread. Poni ej
przedstawi em jej ogóln posta .
final void setPriority(int priorytet)
W tym przypadku parametr priorytet okre la now warto priorytetu dla w tku, dla którego
wywo ano metod . Warto parametru priorytet musi nale e do przedzia u od MIN_PRIORITY
do MAX_PRIORITY. Obecnie sta e te maj warto ci odpowiednio 1 i 10. Aby przywróci w t-
kowi zwyk y priorytet, podajesz warto NORM_PRIORITY, obecnie równ 5. Wymienione warto ci
priorytetów zosta y zadeklarowane jako static final w klasie Thread.
Bie cy priorytet w tku mo esz uzyska , wywo uj c metod getPriority() zdefiniowan
w klasie Thread, któr przedstawiam poni ej:
final int getPriority( )
Przyk ad programu zamieszczony na listingu 11.7 demonstruje u ycie dwóch w tków o ró nych
priorytetach. W tki te tworzone s jako instancje klasy Priority. Metoda run() tej klasy zawiera
p tl zliczaj c iteracje. P tla ko czy dzia anie, gdy wykona 10 000 000 iteracji lub gdy
zmienna stop zadeklarowana jako static ma warto true. Pocz tkowo zmienna ta ma
warto false, a warto true nadaje jej ten w tek, który pierwszy zako czy swoje dzia anie.
W ten sposób drugi z w tków równie ko czy swoje dzia anie, gdy tylko otrzyma czas proce-
sora. W ka dym przebiegu p tli a cuch currentName jest porównywany z nazw wykony-
wanego w tku. Je li s ró ne, oznacza to, e nast pi o prze czenie w tków. Wtedy wy wie-
tlona zostaje nazwa nowego w tku, która zostaje równie przypisana zmiennej currentName.
Wy wietlanie informacji na skutek prze czenia w tku umo liwia u ytkownikowi obserwacj
dost pu obu w tków do procesora. Po zako czeniu dzia ania obu w tków program wy wietla
liczb iteracji obu p tli.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 379
Listing 11.7. PriorityDemo.java
// Demonstruje priorytety w tków.
class Priority implements Runnable {
int count;
Thread thrd;
static boolean stop = false;
static String currentName;
/* Tworzy nowy w tek. Zwró uwag , e ten
konstruktor nie uruchamia w tków. */
Priority(String name) {
thrd = new Thread(this, name);
count = 0;
currentName = name;
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
do {
count++;
if(currentName.compareTo(thrd.getName()) != 0) {
currentName = thrd.getName();
System.out.println(currentName + " jest wykonywany.");
}
W tek, który pierwszy
osi gnie 10 000 000,
} while(stop == false && count < 10000000);
zatrzymuje wszystkie w tki.
stop = true;
System.out.println("\n" + thrd.getName() +
" ko czy dzia anie.");
}
}
class PriorityDemo {
public static void main(String args[]) {
Priority mt1 = new Priority("W tek o wysokim priorytecie");
Priority mt2 = new Priority("W tek o niskim priorytecie");
// okre la priorytet w tków
mt1.thrd.setPriority(Thread.NORM_PRIORITY+2); W tek mt1 otrzymuje
mt2.thrd.setPriority(Thread.NORM_PRIORITY-2); wy szy priorytet ni w tek mt2.
// uruchamia w tki
mt1.thrd.start();
mt2.thrd.start();
try {
mt1.thrd.join();
mt2.thrd.join();
}
catch(InterruptedException exc) {
System.out.println("G ówny w tek rozpoczyna dzia anie.");
}
Poleć książkę
Kup książkę
380 Java. Przewodnik dla pocz tkuj cych
System.out.println("\nW tek o wysokim priorytecie odliczy do " +
mt1.count);
System.out.println("W tek o niskim priorytecie odliczy do " +
mt2.count);
}
}
A oto przyk ad dzia ania programu:
W tek o wysokim priorytecie rozpoczyna dzia anie.
W tek o wysokim priorytecie jest wykonywany.
W tek o niskim priorytecie rozpoczyna dzia anie.
W tek o niskim priorytecie jest wykonywany.
W tek o wysokim priorytecie jest wykonywany.
W tek o niskim priorytecie ko czy dzia anie.
W tek o wysokim priorytecie ko czy dzia anie.
W tek o wysokim priorytecie odliczy do 10000000
W tek o niskim priorytecie odliczy do 8183
W tym przypadku w tek o wysokim priorytecie zaw aszczy wi kszo czasu procesora.
Oczywi cie dok adny wynik dzia ania programu zale y od liczby procesorów w systemie, ich
szybko ci, systemu operacyjnego i liczby innych zada wykonywanych równocze nie przez
system.
Ekspert odpowiada
Pytanie: Czy sposób implementacji wielozadaniowo ci w konkretnym systemie operacyjnym ma
wp yw na to, ile czasu procesora otrzymuje w tek?
Odpowied : Oprócz priorytetu w tku najwi kszy wp yw na wykonanie w tku ma w a nie sposób imple-
mentacji wielozadaniowo ci i szeregowania zada w systemie operacyjnym. Niektóre systemy sto-
suj wielozadaniowo z wyw aszczaniem, co gwarantuje, e ka dy w tek otrzymuje czas procesora,
przynajmniej okazjonalnie. W systemach, które nie u ywaj wyw aszczania, wykonywany w tek musi
sam zwolni procesor, zanim b dzie mo liwe wykonywanie innego w tku. W takich systemach atwo
o sytuacj , w której jeden w tek zaw aszczy procesor, uniemo liwiaj c wykonywanie innych w tków.
Synchronizacja
Gdy u ywasz w programie wielu w tków, mo e pojawi si konieczno skoordynowania
dzia ania niektórych z nich. Proces, który to umo liwia, nazywamy synchronizacj . Najcz st-
szym powodem synchronizacji jest sytuacja, gdy dwa lub wi cej w tków wymaga dost pu
do wspó dzielonego zasobu, który mo e by u ywany w danej chwili tylko przez jeden w tek.
Na przyk ad gdy jeden w tek zapisuje dane w pliku, inny w tek nie mo e wykonywa zapisu
w tym samym pliku w tym samym czasie. Innym powodem stosowania synchronizacji jest
oczekiwanie w tku na zdarzenie, którego przyczyn jest inny w tek. W tym przypadku musi
istnie sposób zawieszenia wykonywania w tku do momentu, w którym nast pi wspomniane
zdarzenie. Wtedy w tek musi wznowi wykonywanie.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 381
Kluczem do synchronizacji w tków w Javie jest koncepcja monitora. Monitor kontroluje
dost p do obiektu, u ywaj c blokad. Gdy dost p do obiektu zostanie zablokowany przez jeden
w tek, obiekt nie jest dost pny dla innych w tków. Dopiero gdy w tek przestanie u ywa
obiektu, blokada zostaje zwolniona i obiekt jest dost pny dla innych w tków.
Z ka dym obiektem Javy zwi zany jest monitor. Monitory zosta y wbudowane w j zyk Java
i dzi ki temu Java umo liwia synchronizacj dost pu do wszystkich obiektów. Odbywa si
ona przez zastosowanie s owa kluczowego synchronized i kilku metod, którymi dysponuj
wszystkie obiekty. Poniewa Jav od pocz tku projektowano z my l o synchronizacji, pos u-
giwanie si tym mechanizmem jest du o atwiejsze, ni mog oby si wydawa . W wielu pro-
gramach synchronizacja dost pu do obiektów odbywa si prawie w transparentny sposób.
Istniej dwa sposoby zastosowania synchronizacji w Twoim kodzie. Oba wymagaj u ycia
s owa kluczowego synchronized i oba zostan omówione w tym rozdziale.
Synchronizacja metod
Synchronizacj dost pu do metody mo esz zapewni , u ywaj c w jej deklaracji s owa klu-
czowego synchronized. Wywo anie takiej metody powoduje, e monitor blokuje dost p do
obiektu. Gdy obiekt jest zablokowany, aden inny w tek nie mo e wywo a tej metody ani
adnej innej metody tego obiektu zadeklarowanej w jego klasie jako synchronized. Gdy dzia-
anie metody ko czy si , monitor odblokowuje obiekt, umo liwiaj c tym samym jego u ycie
przez kolejny w tek. W ten sposób synchronizacja dost pu do obiektu odbywa si praktycznie
bez jakiegokolwiek dodatkowego wysi ku ze strony programisty.
Program przedstawiony na listingu 11.8 demonstruje dzia anie mechanizmu synchronizacji na
przyk adzie metody sumArray() sumuj cej elementy tablicy zawieraj cej liczby ca kowite.
Listing 11.8. Sync.java
// Synchronizacja dost pu do metody.
class SumArray {
private int sum;
synchronized int sumArray(int nums[]) { Dost p do metody sumArray()
sum = 0; // zeruje sum jest synchronizowany.
for(int i=0; i sum += nums[i];
System.out.println(Thread.currentThread().getName() +
" wyliczy sum cz ciow równ " + sum);
try {
Thread.sleep(10); // umo liwia prze czenie w tków
}
catch(InterruptedException exc) {
System.out.println("W tek zosta przerwany.");
}
}
return sum;
Poleć książkę
Kup książkę
382 Java. Przewodnik dla pocz tkuj cych
}
}
class MyThread implements Runnable {
Thread thrd;
static SumArray sa = new SumArray();
int a[];
int answer;
// Tworzy nowy w tek.
MyThread(String name, int nums[]) {
thrd = new Thread(this, name);
a = nums;
thrd.start(); // uruchamia w tek
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
int sum;
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
answer = sa.sumArray(a);
System.out.println(thrd.getName() +
" wyliczy sum równ " + answer);
System.out.println(thrd.getName() + " ko czy dzia anie.");
}
}
class Sync {
public static void main(String args[]) {
int a[] = {1, 2, 3, 4, 5};
MyThread mt1 = new MyThread("W tek potomny nr 1", a);
MyThread mt2 = new MyThread("W tek potomny nr 2", a);
try {
mt1.thrd.join();
mt2.thrd.join();
}
catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
}
A oto przyk ad dzia ania tego programu (kolejno komunikatów mo e by w Twoim przy-
padku nieco inna).
W tek potomny nr 1 rozpoczyna dzia anie.
W tek potomny nr 2 rozpoczyna dzia anie.
W tek potomny nr 1 wyliczy sum cz ciow równ 1
W tek potomny nr 1 wyliczy sum cz ciow równ 3
W tek potomny nr 1 wyliczy sum cz ciow równ 6
W tek potomny nr 1 wyliczy sum cz ciow równ 10
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 383
W tek potomny nr 1 wyliczy sum cz ciow równ 15
W tek potomny nr 2 wyliczy sum cz ciow równ 1
W tek potomny nr 1 wyliczy sum równ 15
W tek potomny nr 1 ko czy dzia anie.
W tek potomny nr 2 wyliczy sum cz ciow równ 3
W tek potomny nr 2 wyliczy sum cz ciow równ 6
W tek potomny nr 2 wyliczy sum cz ciow równ 10
W tek potomny nr 2 wyliczy sum cz ciow równ 15
W tek potomny nr 2 wyliczy sum równ 15
W tek potomny nr 2 ko czy dzia anie.
Przeanalizujmy szczegó owo dzia anie tego programu. Tworzy on trzy klasy. Pierwsz z nich
jest SumArray. Zawiera ona metod sumArray(), która oblicza sum elementów tablicy przecho-
wuj cej warto ci ca kowite. Druga klasa, MyThread, u ywa obiektu typu SumArray. Referencj
sa tego obiektu zadeklarowa em jako static i wobec tego istnieje tylko jedna jej kopia
wspó dzielona przez wszystkie obiekty klasy MyThread. Ostatnia z klas, Sync, tworzy dwa
w tki obliczaj ce sum zawarto ci tej samej tablicy.
Metoda sumArray() wywo uje metod sleep(), aby umo liwi prze czenie w tków. Jednak
prze czenie nie jest mo liwe, gdy metoda sumArray() zosta a zadeklarowana jako synchronized
i wobec tego nie mo e by u ywana równocze nie przez dwa lub wi cej w tków. Zatem gdy
drugi z w tków potomnych rozpoczyna dzia anie, nie mo e wywo a metody sumArray(),
dopóki nie wykona jej pierwszy w tek. Synchronizacja dost pu do metody gwarantuje w tym
wypadku poprawny wynik jej dzia ania.
Aby w pe ni zrozumie efekt s owa kluczowego synchronized, spróbuj usun je z deklaracji
metody sumArray(). Dost p do tej metody przestanie podlega synchronizacji i wiele w tków
b dzie mog o jej u ywa równocze nie. Problem polega na tym, e suma cz ciowa jest prze-
chowywana w sk adowej sum, która jest modyfikowana przez ka dy w tek wywo uj cy metod
sumArray() dla obiektu sa zadeklarowanego jako static. Je li zatem dwa w tki wywo aj
równocze nie metod sa.sumArray(), wyniki jej dzia ania b d niepoprawne, poniewa sk a-
dowa sum b dzie przechowywa na przemian sumy cz ciowe obliczane przez ka dy z w t-
ków. Poni ej przedstawi em przyk ad dzia ania programu po usuni ciu s owa kluczowego
synchronized z deklaracji metody sumArray() (wynik dzia ania w Twoim przypadku mo e
si ró ni ).
W tek potomny nr 1 rozpoczyna dzia anie.
W tek potomny nr 2 rozpoczyna dzia anie.
W tek potomny nr 1 wyliczy sum cz ciow równ 1
W tek potomny nr 2 wyliczy sum cz ciow równ 1
W tek potomny nr 1 wyliczy sum cz ciow równ 3
W tek potomny nr 1 wyliczy sum cz ciow równ 8
W tek potomny nr 2 wyliczy sum cz ciow równ 8
W tek potomny nr 2 wyliczy sum cz ciow równ 11
W tek potomny nr 1 wyliczy sum cz ciow równ 15
W tek potomny nr 1 wyliczy sum cz ciow równ 20
W tek potomny nr 2 wyliczy sum cz ciow równ 24
W tek potomny nr 2 wyliczy sum cz ciow równ 29
W tek potomny nr 1 wyliczy sum równ 24
W tek potomny nr 1 ko czy dzia anie.
W tek potomny nr 2 wyliczy sum równ 29
W tek potomny nr 2 ko czy dzia anie.
Poleć książkę
Kup książkę
384 Java. Przewodnik dla pocz tkuj cych
Powy sze informacje pokazuj , e oba w tki potomne wywo uj równocze nie metod
sa.sumArray(), przypisuj c sk adowej sum niew a ciwe warto ci. Zanim przejdziemy do nast p-
nego zagadnienia, podsumujmy najwa niejsze fakty zwi zane z synchronizacj metod:
synchronizacja metody polega na umieszczeniu s owa kluczowego synchronized
w deklaracji metody;
synchronizacja dost pu do metody powoduje, e jej wywo anie dla dowolnego obiektu
powoduje jego zablokowanie i aden inny w tek nie mo e wywo a dla tego samego
obiektu adnej metody zadeklarowanej jako synchronized;
inne w tki próbuj ce wywo a metod zadeklarowan jako synchronized dla obiektu,
do którego dost p zosta zablokowany przez monitor, przechodz w stan oczekiwania
do momentu, w którym obiekt zostanie odblokowany;
gdy w tek ko czy wykonywanie metody synchronized, dost p do obiektu zostaje
odblokowany.
Synchronizacja instrukcji
Chocia deklarowanie metod jako synchronized stanowi prosty i efektywny sposób wyko-
rzystania mechanizmu synchronizacji, nie sprawdza si on we wszystkich sytuacjach. Na
przyk ad mo e wyst pi konieczno zapewnienia synchronizacji dost pu do metody, która
nie zosta a zadeklarowana jako synchronized. Mo e si to zdarzy , gdy u ywasz cudzych
klas i nie masz dost pu do ich kodu ród owego. Nie mo esz zatem doda s owa kluczowego
synchronized w deklaracji interesuj cej Ci metody. W jaki sposób mo esz zatem zapewni
synchronizacj dost pu do obiektu tej klasy? Rozwi zanie tego problemu jest na szcz cie
bardzo proste: wystarczy umieszcza wywo ania metod tej klasy w bloku oznaczonym jako
synchronized.
Poni ej przedstawi em ogóln posta bloku synchronized:
synchronized(refobj) {
// instrukcje wymagaj ce synchronizacji
}
W tym przypadku refobj jest referencj obiektu, do którego dost p wymaga synchronizacji.
Gdy w tek rozpocznie wykonywanie bloku synchronized, aden inny w tek nie mo e wywo a
metody dla obiektu refobj, dopóki bie cy w tek nie opu ci tego bloku.
Kolejny sposób synchronizacji wywo a metody sumArray() polega zatem na ich umieszczeniu
w bloku synchronized. Ilustruje to wersja programu przedstawiona na listingu 11.9.
Listing 11.9. Sync2.java
// U ywa bloku synchronized
// dla synchronizacji dost pu
// do metody sumArray.
class SumArray {
private int sum;
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 385
int sumArray(int nums[]) { W tym wypadku dost p do metody sumArray()
sum = 0; // zeruje sum nie podlega synchronizacji.
for(int i=0; i sum += nums[i];
System.out.println(Thread.currentThread().getName() +
" wyliczy sum cz ciow równ " + sum);
try {
Thread.sleep(10); // umo liwia prze czenie w tków
}
catch(InterruptedException exc) {
System.out.println("W tek zosta przerwany.");
}
}
return sum;
}
}
class MyThread implements Runnable {
Thread thrd;
static SumArray sa = new SumArray();
int a[];
int answer;
// Tworzy nowy w tek.
MyThread(String name, int nums[]) {
thrd = new Thread(this, name);
a = nums;
thrd.start(); // uruchamia w tek
}
// Rozpoczyna wykonywanie nowego w tku.
public void run() {
int sum;
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
// synchronizuje wywo ania metody sumArray()
synchronized(sa) { Synchronizacja wywo a metody sumArray() dla obiektu sa.
answer = sa.sumArray(a);
}
System.out.println(thrd.getName() +
" wyliczy sum równ " + answer);
System.out.println(thrd.getName() + " ko czy dzia anie.");
}
}
class Sync2 {
public static void main(String args[]) {
int a[] = {1, 2, 3, 4, 5};
MyThread mt1 = new MyThread("W tek potomny nr 1", a);
MyThread mt2 = new MyThread("W tek potomny nr 2", a);
try {
mt1.thrd.join();
Poleć książkę
Kup książkę
386 Java. Przewodnik dla pocz tkuj cych
mt2.thrd.join();
} catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
}
Wynik dzia ania tej wersji programu b dzie poprawny, taki sam jak w przypadku wykorzy-
stania metody zadeklarowanej jako synchronized.
Ekspert odpowiada
Pytanie: S ysza em co o  API wspó bie no ci . Do czego one s u ? Do czego s u y szkielet
Fork/Join?
Odpowied : API wspó bie no ci udost pniono w pakiecie java.util.concurrent (i jego pakietach
podrz dnych) w celu umo liwienia w Javie programowania wspó bie nego. Klasy te implementuj
mi dzy innymi synchronizatory, pule w tków, mened ery wykonania i blokady umo liwiaj ce sterowa-
nie wykonaniem w tków. Jedn z najciekawszych mo liwo ci oferowanych przez API wspó bie no ci
jest szkielet Fork/Join wprowadzony w JDK 7.
Szkielet ten umo liwia tak zwane programowanie równoleg e. Nazwy tej u ywa si do okre lenia
technik pozwalaj cych wykorzysta zalety komputerów o dwu lub wi cej procesorach (w czaj c w to
systemy wielordzeniowe) poprzez podzia zadania na podzadania i wykonywanie ka dego podzada-
nia na osobnym procesorze. Rozwi zanie takie pozwala zwi kszy szybko wykonywania dzia ania
i poprawi efektywno systemu. Podstawow zalet szkieletu Fork/Join jest atwo u ycia. Upraszcza
on tworzenie kodu wielow tkowego, który automatycznie skaluje si tak, aby wykorzysta liczb
procesorów dost pnych w systemie. Tym samym sprowadza tworzenie rozwi za wspó bie nych do
poziomu nie trudniejszego ni typowe zadania programowania, takie jak na przyk ad operacje na
elementach tablicy. API wspó bie no ci, a w szczególno ci szkielet Fork/Join, warte s poznania, gdy
nabierzesz wi kszego do wiadczenia w tworzeniu programów wielow tkowych.
Komunikacja mi dzyw tkowa
Rozwa my nast puj c sytuacj . W tek T wykonuje w a nie metod zadeklarowan jako
synchronized i wymaga dost pu do zasobu R, który jest tymczasowo niedost pny. Co powi-
nien zrobi w tek T? Je li zacznie sprawdza w p tli dost pno zasobu R, to zablokuje
u ywany obiekt, uniemo liwiaj c dost p innym w tkom. Rozwi zanie takie jest dalekie od
optymalnego, poniewa cz ciowo redukuje zalety programowania wielow tkowego. Lepiej
b dzie, je li w tek T zwolni tymczasowo wykorzystywany obiekt, umo liwiaj c wykonywanie
innych w tków. Gdy zasób R stanie si dost pny, w tek T zostanie powiadomiony i wznowi
dzia anie. Takie rozwi zanie wymaga jednak komunikacji mi dzyw tkowej, dzi ki której jeden
w tek mo e powiadomi inne, e zosta zablokowany, a sam zosta powiadomiony, e mo e
wznowi dzia anie. Java umo liwia komunikacj mi dzyw tkow za pomoc metod wait(),
notify() i notifyAll().
Metody wait(), notify() i notifyAll() s dost pne dla ka dego obiektu, poniewa zosta y
zaimplementowane w klasie Object. Metody te mog by wywo ywane tylko w kontek cie
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 387
dzia ania mechanizmu synchronizacji. U ywamy ich w nast puj cy sposób. Gdy w tek zostaje
czasowo zablokowany, wywo uje metod wait(). Wykonanie w tku zostaje zawieszone,
a monitor obiektu zwalnia blokad , umo liwiaj c innemu w tkowi dost p do obiektu. Zawie-
szony w tek wznowi pó niej swoje dzia anie, gdy inny w tek wywo a dla tego samego obiektu
metod notify() lub notifyAll().
Poni ej przedstawi em ró ne wersje metody wait() zdefiniowane w klasie Object:
final void wait( ) throws InterruptedException
final void wait(long milisekund) throws InterruptedException
final void wait(long milisekund, int nanosekund) throws InterruptedException
Pierwsza wersja zawiesza wykonywanie w tku do momentu wywo ania metody notify() lub
notifyAll(). Druga podobnie, ale w tek nie b dzie oczekiwa d u ej ni podan liczb
milisekund. Trzecia wersja umo liwia jeszcze dok adniejsze okre lenie maksymalnego czasu
oczekiwania z dok adno ci do pojedynczych nanosekund.
Poni ej przedstawi em ogóln posta metod notify() i notifyAll():
final void notify( )
final void notifyAll( )
Wywo anie metody notify() powoduje wznowienie wykonywania oczekuj cego w tku.
Wywo anie metody notifyAll() powiadamia wszystkie w tki, a dost p do obiektu uzyskuje
w tek o najwy szym priorytecie.
Zanim przyjrzymy si przyk adowi zastosowania tych metod, musz uczyni jeszcze jedn
wa n uwag . Chocia w normalnych warunkach metoda wait() powoduje oczekiwanie
w tku na wywo anie metody notify() lub notifyAll(), istnieje bardzo rzadko spotykana
mo liwo , e w tek zako czy oczekiwanie na skutek tak zwanego fa szywego przebudzenia.
Omówienie skomplikowanych warunków, które prowadz do takiej sytuacji, wykracza poza
zakres tej ksi ki. Ze wzgl du na mo liwo wyst pienia fa szywego przebudzenia w tku
firma Oracle zaleca wywo ywanie metody wait() w p tli sprawdzaj cej warunek, na którego
spe nienie oczekuje w tek. W nast pnym przyk adzie zastosujemy t technik .
Przyk ad u ycia metod wait() i notify()
Aby atwiej Ci by o zrozumie zastosowania metod wait() i notify(), stworzymy teraz program
symuluj cy tykanie zegara przez wy wietlanie na przemian s ów  tik i  tak . W tym celu
stworzymy klas TickTock zawieraj c dwie metody: tick() i tock(). Metoda tick() wy wie-
tli s owo "tik", a metoda tock() s owo "tak". Aby uruchomi symulacj zegara, utworzymy
dwa w tki, z których jeden b dzie wywo ywa metod tick(), a drugi metod tock(). W tki
te musz by wykonywane w taki sposób, aby program wy wietla na przemian s owa  tik
i  tak . Kod ród owy programu przedstawi em na listingu 11.10.
Listing 11.10. ThreadCom.java
// U ywa metod wait() i notify()
// do stworzenia symulacji zegara.
class TickTock {
Poleć książkę
Kup książkę
388 Java. Przewodnik dla pocz tkuj cych
String state; // przechowuje stan zegara
synchronized void tick(boolean running) {
if(!running) { // zatrzymuje zegar
state = "ticked";
notify(); // powiadamia oczekuj cy w tek
return;
}
System.out.print("tik ");
state = "ticked"; // zmienia stan zegara na "ticked"
notify(); // umo liwia wykonanie metody tock() Metoda tick() powiadamia metod tock().
try {
while(!state.equals("tocked"))
wait(); // oczekuje na zako czenie metody tock() Metoda tick() czeka na zako czenie
} metody tock().
catch(InterruptedException exc) {
System.out.println("W tek zosta przerwany.");
}
}
synchronized void tock(boolean running) {
if(!running) { // zatrzymuje zegar
state = "tocked";
notify(); // powiadamia oczekuj cy w tek
return;
}
System.out.println("tak");
state = "tocked"; // zmienia stan zegara na "tocked"
notify(); // umo liwia wykonanie metody tick() Metoda tock() powiadamia metod tick().
try {
while(!state.equals("ticked"))
wait(); // oczekuje na zako czenie metody tick() Metoda tock() czeka
} na zako czenie metody tick().
catch(InterruptedException exc) {
System.out.println("W tek zosta przerwany.");
}
}
}
class MyThread implements Runnable {
Thread thrd;
TickTock ttOb;
// Tworzy nowy w tek.
MyThread(String name, TickTock tt) {
thrd = new Thread(this, name);
ttOb = tt;
thrd.start(); // uruchamia w tek
}
// Rozpoczyna wykonywanie nowego w tku.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 389
public void run() {
if(thrd.getName().compareTo("tik") == 0) {
for(int i=0; i<5; i++) ttOb.tick(true);
ttOb.tick(false);
}
else {
for(int i=0; i<5; i++) ttOb.tock(true);
ttOb.tock(false);
}
}
}
class ThreadCom {
public static void main(String args[]) {
TickTock tt = new TickTock();
MyThread mt1 = new MyThread("tik", tt);
MyThread mt2 = new MyThread("tak", tt);
try {
mt1.thrd.join();
mt2.thrd.join();
} catch(InterruptedException exc) {
System.out.println("W tek g ówny zosta przerwany.");
}
}
}
A oto wynik dzia ania tego programu:
tik tak
tik tak
tik tak
tik tak
tik tak
Przyjrzyjmy si bli ej dzia aniu tego programu. Sercem symulacji zegara jest klasa TickTock.
Zawiera ona dwie metody, tick() i tock(), które komunikuj si ze sob , aby zagwarantowa ,
e po metodzie tick() zostanie zawsze wykonana metoda tock(), a po niej znowu metoda
tick() i tak dalej. Zwró uwag na sk adow state. Gdy dzia a symulacja zegara, sk adowa
state przechowuje a cuch "ticked" lub "tocked" informuj cy o bie cym stanie zegara.
Metoda main() tworzy obiekt tt klasy TickTock i u ywa go do uruchomienia dwóch w tków
potomnych.
W tki te opieraj si na obiektach typu MyThread. Konstruktor klasy MyThread ma dwa para-
metry. Pierwszym jest nazwa w tku, "tik" lub "tak". Drugim jest referencja obiektu typu
TickTock, tt w tym przypadku. Wewn trz metody run() klasy MyThread wywo ana zostaje
metoda tick(), je li nazw w tku jest "tik". Je li nazw jest "tak", wywo ana zostaje metoda
tock(). Ka da z tych metod zostaje wywo ana pi razy z argumentem true. Ostatnie wywo a-
nie przekazuje ka dej metodzie argument false, co powoduje zatrzymanie symulacji zegara.
Najwa niejsz cz symulacji zegara stanowi metody tick() i tock() klasy TickTock. Przyj-
rzyjmy si metodzie tick(), której kod przedstawi em poni ej.
Poleć książkę
Kup książkę
390 Java. Przewodnik dla pocz tkuj cych
synchronized void tick(boolean running) {
if(!running) { // zatrzymuje zegar
state = "ticked";
notify(); // powiadamia oczekuj cy w tek
return;
}
System.out.print("tik ");
state = "ticked"; // zmienia stan zegara na "ticked"
notify(); // umo liwia wykonanie metody tock()
try {
while(!state.equals("tocked"))
wait(); // oczekuje na zako czenie metody tock()
}
catch(InterruptedException exc) {
System.out.println("W tek zosta przerwany.");
}
}
Zwró uwag , e metoda tick() zosta a zadeklarowana jako synchronized. Jak ju wspo-
mnia em, metody wait() i notify() znajduj zastosowanie tylko w przypadku synchronizacji
dost pu do metod. Metoda rozpoczyna dzia anie od sprawdzenia warto ci parametru running.
Parametr ten jest u ywany do zako czenia dzia ania symulacji zegara. Je li ma warto false,
zegar zostaje zatrzymany. W takim przypadku sk adowa state otrzymuje warto "ticked"
i wywo ana zostaje metoda notify(), aby umo liwi dzia anie oczekuj cego w tku. Za chwil
wrócimy jeszcze do tego punktu.
Je li zegar dzia a, metoda wy wietla s owo "tik", nadaje sk adowej state warto "ticked"
i wywo uje metod notify(). Wywo anie metody notify() umo liwia wznowienie dzia ania
w tku, który oczekiwa na dost p do tego samego obiektu. Nast pnie w p tli while wywo y-
wana jest metoda wait(). Wywo anie metody wait() powoduje zawieszenie wykonywania
metody tick() do momentu, w którym inny w tek wywo a metod notify(). Zatem wyko-
nanie p tli zostanie równie wstrzymane do momentu, w którym inny w tek wywo a metod
notify() dla tego samego obiektu. W rezultacie wywo anie metody tick() powoduje wy wie-
tlenie jednego s owa "tik", wznowienie innego w tku i zawieszenie w asnego wykonania.
P tla while, która wywo uje metod wait(), sprawdza, czy sk adowa state ma warto "tocked",
co zdarzy si dopiero po wywo aniu metody tock(). Jak ju wcze niej wyja ni em, zastosowa-
nie p tli while do sprawdzania tego warunku ma zapobiec fa szywemu przebudzeniu w tku.
Gdy metoda wait() zwróci sterowanie, a sk adowa state nie ma warto ci "tocked", oznacza to
w a nie wyst pienie fa szywego przebudzenia i metoda wait() zostaje wywo ana ponownie.
Metoda tock() stanowi dok adn kopi metody tick(), z t ró nic , e wy wietla s owo "tak"
i nadaje sk adowej state warto "tocked". Zatem metoda tock() najpierw wy wietla s owo
"tak", wywo uje metod notify() i nast pnie zawiesza swoje dzia anie. Metody tick() i tack()
mog dzia a tylko razem, przy czym po wywo aniu metody tick() musi nast pi wywo anie
metody tock(), po którym znowu nast puje wywo anie metody tick() i tak dalej. Dzia anie
tych metod jest wzajemnie zsynchronizowane.
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 391
Po zatrzymaniu zegara metoda notify() zostaje wywo ana ostatni raz, aby wznowi dzia anie
drugiego w tku. Pami taj, e metody tick() i tock() wywo uj zawsze metod wait() po
wy wietleniu komunikatu. Zatem gdy zegar zostanie zatrzymany, jeden z w tków b dzie si
znajdowa w stanie oczekiwania. Jego dzia anie mo na wznowi w a nie za pomoc ostatniego
wywo ania metody notify(). Spróbuj usun to wywo anie metody notify() i zaobserwo-
wa efekt. Zobaczysz, e program  zawiesi si  i b dziesz musia przerwa jego dzia anie,
naciskaj c Ctrl+C. Dzieje si tak, poniewa gdy ostatnie wywo anie metody tock() spowoduje
wywo anie metody wait(), to nie b dzie odpowiadaj cego mu wywo ania metody notify(),
które pozwoli oby metodzie tock() zako czy dzia anie. Zatem metoda tock() oczekuje
wtedy w niesko czono .
Je li masz jeszcze w tpliwo ci, czy rzeczywi cie wywo ania metod wait() i notify() s
konieczne dla prawid owego dzia ania symulacji zegara, zast p klas TockTock jej poni sz
wersj , z której usun em wywo ania metod wait() i notify().
// Bez wywo a metod wait() i notify().
class TickTock {
String state; // przechowuje stan zegara
synchronized void tick(boolean running) {
if(!running) { // zatrzymuje zegar
state = "ticked";
return;
}
System.out.print("tik ");
state = "ticked"; // zmienia stan zegara na "ticked"
}
synchronized void tock(boolean running) {
if(!running) { // zatrzymuje zegar
state = "tocked";
return;
}
System.out.println("tak");
state = "tocked"; // zmienia stan zegara na "tocked"
}
}
Po zast pieniu klasy TickTock now wersj program wy wietli poni sze komunikaty:
tik tik tik tik tik tak
tak
tak
tak
tak
Metody tick() i tock() nie wspó pracuj ju ze sob !
Poleć książkę
Kup książkę
392 Java. Przewodnik dla pocz tkuj cych
Ekspert odpowiada
Pytanie: Spotka em si z terminem zakleszczenie w odniesieniu do nieprawid owo dzia aj cych
programów wielow tkowych. Na czym polega ta sytuacja i jak jej unika ? Na czym polega sytu-
acja wy cigu i jak mog jej unikn ?
Odpowied : Zakleszczenie, jak wskazuje nazwa, jest sytuacj , w której jeden w tek czeka, a drugi
w tek wykona pewn operacj , ale drugi w tek czeka w a nie na pierwszy. Dzia anie obu w tków jest
wstrzymane, w tki oczekuj na siebie wzajemnie. Przypomina to troch dwie nadzwyczaj uprzejme
osoby, które nie mog przekroczy progu, poniewa ka da chce ust pi drugiej.
Unikanie zakleszcze wydaje si proste, ale takie nie jest. Sama analiza kodu programu cz sto nie
wystarcza do ustalenia przyczyny zakleszczenia, poniewa w czasie wykonania programu mi dzy
w tkami mog zachodzi skomplikowane zale no ci czasowe. Unikanie zakleszcze wymaga dba-
o ci w programowaniu oraz wszechstronnego testowania. Pami taj, e je li program wielow tkowy
czasami zawiesza si , to najbardziej prawdopodobn tego przyczyn jest w a nie zakleszczenie.
Sytuacja wy cigu wyst puje, gdy dwa (lub wi cej) w tków próbuje uzyska równocze nie dost p do
wspó dzielonego zasobu, ale odbywa si to bez odpowiedniej synchronizacji. Na przyk ad jeden w tek
mo e przypisywa zmiennej now warto , podczas gdy inny w tek w tym samym czasie zwi ksza
warto tej samej zmiennej. Je li nie zastosujemy synchronizacji, to wynik tych operacji b dzie zale-
e od kolejno ci wykonania w tków (czy drugi w tek najpierw zwi kszy oryginaln warto zmien-
nej, czy raczej pierwszy w tek zd y przypisa jej wcze niej now warto ?). W takich sytuacjach
mówi si o wy cigu w tków, poniewa ostateczny wynik operacji zale y od tego, który w tek b dzie
pierwszy. Podobnie jak w przypadku zakleszczenia wykrycie sytuacji wy cigu mo e by trudne. Naj-
lepszym rozwi zaniem jest zapobieganie: staranne programowanie z zastosowaniem odpowiedniej
synchronizacji dost pu do wspó dzielonych zasobów.
Wstrzymywanie, wznawianie
i ko czenie dzia ania w tków
Mo liwo wstrzymania wykonywania w tku bywa przydatna w pewnych sytuacjach. Na
przyk ad osobny w tek mo e wy wietla czas. Je li u ytkownik nie chce ogl da zegara,
wtedy mo na wstrzyma dzia anie w tku, który go wy wietla. Niezale nie od przyczyny wstrzy-
manie wykonywania w tku nie powinno stanowi problemu. Podobnie jak pó niejsze wzno-
wienie jego dzia ania.
Mechanizm wstrzymywania, wznawiania i ko czenia dzia ania w tków ró ni si we wcze-
snych i obecnych wersjach Javy. W wersjach wcze niejszych ni Java 2 do wstrzymywania,
wznawiania i ko czenia dzia ania w tków s u y y odpowiednio metody suspend(), resume()
i stop() zdefiniowane w klasie Thread. Maj one nast puj c posta :
final void resume( )
final void suspend( )
final void stop( )
Mimo e metody te wydaj si w a ciwym rozwi zaniem kwestii zarz dzania wykonaniem
w tków, obecnie ich u ycie nie jest zalecane. W Javie 2 uznano metod suspend() klasy
Thread za przestarza . Powodem by a mo liwo doprowadzenia w pewnych sytuacjach do
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 393
zakleszcze na skutek u ycia tej metody. Metod resume() równie uznano za przestarza . Nie
powodowa a ona adnych problemów, ale jej u ycie bez metody suspend() nie mia o sensu.
Metod stop() równie uznano za przestarza w Javie 2, poniewa w pewnych warunkach
jej u ycie mog o by przyczyn powa nych problemów.
Skoro nie mo na ju u ywa metod suspend(), resume() i stop() do sterowania dzia aniem
w tku, mog oby si wydawa , e nie ma sposobu, by wstrzyma , wznowi lub zako czy
wykonywanie w tku. Nic bardziej b dnego. Wystarczy zaprojektowa w tek w taki sposób,
aby metoda run() sprawdza a okresowo, czy powinna wstrzyma , wznowi lub zako czy
swoje dzia anie. Zwykle osi ga si to przez wprowadzenie w klasie w tków dwóch znaczników:
jednego dla wstrzymania i wznowienia w tku i drugiego dla zatrzymania w tku. W przypadku
operacji wstrzymania i wznowienia w tku, je li odpowiedni znacznik nie jest ustawiony,
metoda run() musi kontynuowa wykonywanie w tku. W przeciwnym razie musi wstrzyma
swoje dzia anie. Je li ustawiony jest drugi ze znaczników, oznaczaj cy zatrzymanie w tku,
metoda run() musi zako czy dzia anie.
Na listingu 11.11 przedstawi em jeden ze sposobów implementacji w asnych wersji metod
suspend(), resume() i stop().
Listing 11.11. Suspend.java
// Wstrzymywanie, wznawianie i zatrzymywanie w tku.
class MyThread implements Runnable {
Thread thrd;
boolean suspended; Powoduje wstrzymanie wykonania w tku, gdy ma warto true.
boolean stopped; Powoduje zako czenie wykonania w tku, gdy ma warto true.
MyThread(String name) {
thrd = new Thread(this, name);
suspended = false;
stopped = false;
thrd.start();
}
// Punkt wej cia do w tku.
public void run() {
System.out.println(thrd.getName() + " rozpoczyna dzia anie.");
try {
for(int i = 1; i < 1000; i++) {
System.out.print(i + " ");
if((i%10)==0) {
System.out.println();
Thread.sleep(250);
}
// U ywa bloku synchronized, aby sprawdzi
// warto ci sk adowych suspended i stopped.
synchronized(this) { Ten blok synchronized sprawdza warto ci sk adowych
while(suspended) { suspended i stopped.
wait();
}
if(stopped) break;
}
Poleć książkę
Kup książkę
394 Java. Przewodnik dla pocz tkuj cych
}
} catch (InterruptedException exc) {
System.out.println(thrd.getName() + " zosta przerwany.");
}
System.out.println(thrd.getName() + " ko czy dzia anie.");
}
// Zatrzymuje w tek.
synchronized void mystop() {
stopped = true;
// Poni sze instrukcje umo liwiaj zatrzymanie w tku,
// którego wykonanie zosta o wstrzymane.
suspended = false;
notify();
}
// Wstrzymuje dzia anie w tku.
synchronized void mysuspend() {
suspended = true;
}
// Wznawia dzia anie w tku.
synchronized void myresume() {
suspended = false;
notify();
}
}
class Suspend {
public static void main(String args[]) {
MyThread ob1 = new MyThread("W tek potomny klasy MyThread");
try {
Thread.sleep(1000); // umo liwia rozpocz cie wykonywania w tku ob1
ob1.mysuspend();
System.out.println("Wstrzymuj w tek.");
Thread.sleep(1000);
ob1.myresume();
System.out.println("Wznawiam w tek.");
Thread.sleep(1000);
ob1.mysuspend();
System.out.println("Wstrzymuj w tek.");
Thread.sleep(1000);
ob1.myresume();
System.out.println("Wznawiam w tek.");
Thread.sleep(1000);
ob1.mysuspend();
System.out.println("Zatrzymuj w tek.");
ob1.mystop();
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 395
} catch (InterruptedException e) {
System.out.println("W tek g ówny zosta przerwany");
}
// czeka na zako czenie w tku
try {
ob1.thrd.join();
} catch (InterruptedException e) {
System.out.println("W tek g ówny zosta przerwany");
}
System.out.println("W tek g ówny ko czy dzia anie.");
}
}
Poni ej przedstawi em rezultat dzia ania programu (mo e nieco ró ni si w Twoim przypadku).
W tek potomny klasy MyThread rozpoczyna dzia anie.
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
Wstrzymuj w tek.
Wznawiam w tek.
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
Wstrzymuj w tek.
Wznawiam w tek.
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
101 102 103 104 105 106 107 108 109 110
111 112 113 114 115 116 117 118 119 120
Zatrzymuj w tek.
W tek potomny klasy MyThread ko czy dzia anie.
W tek g ówny ko czy dzia anie.
Program ten dzia a w nast puj cy sposób. Klasa MyThread definiuje dwie zmienne typu boolean
o nazwach suspended i stopped, które zarz dzaj operacjami wstrzymania i zatrzymania w tku.
Konstruktor klasy MyThread nadaje tym zmiennym warto pocz tkow false. Metoda run()
zawiera blok synchronized, który sprawdza warto zmiennej suspended. Je li jest ona równa
true, wywo uje metod wait(), aby wstrzyma dzia anie w tku. Aby wstrzyma dzia anie
w tku, wywo ujemy metod mysuspend(), która nadaje zmiennej suspended warto true.
Aby wznowi w tek, wywo ujemy metod myresume(), która nadaje zmiennej suspended
warto false i wywo uje metod notify().
Aby zako czy w tek, wywo ujemy metod mystop(), która nadaje zmiennej stopped warto
true. Dodatkowo metoda mystop() nadaje zmiennej suspended warto false, a nast pnie
wywo uje metod notify(). Jest to konieczne, aby zako czy w tek, którego wykonanie zosta o
wcze niej wstrzymane.
Poleć książkę
Kup książkę
396 Java. Przewodnik dla pocz tkuj cych
Ekspert odpowiada
Pytanie: Wielow tkowo wydaje si by doskona ym sposobem poprawy efektywno ci moich
programów. Czy mo esz poda wskazówk , jak najefektywniej korzysta z tego mechanizmu?
Odpowied : Klucz do efektywnego wykorzystania wielow tkowo ci polega na przestawieniu si z my le-
nia kategoriami sekwencyjnego dzia ania na bardziej równoleg e. Na przyk ad gdy w Twoim progra-
mie istniej dwa podsystemy dzia aj ce zupe nie niezale nie od siebie, powiniene powa nie rozwa-
y mo liwo zaimplementowania ich jako osobnych w tków. Jedno s owo przestrogi. Je li stworzysz
zbyt wiele w tków, mo esz pogorszy efektywno dzia ania programu, zamiast j poprawi . Pami -
taj o narzucie zwi zanym z prze czaniem kontekstu wykonania w tków. Je li Twój program uru-
chomi zbyt wiele w tków, wi kszo czasu procesora zajmie prze czanie kontekstu w tków, a nie
wykonanie programu!
Przyk ad 11.2. Wykorzystanie g ównego w tku
Wszystkie programy w Javie maj przynajmniej jeden w tek wykonania zwany
UseMain.java
w tkiem g ównym. W tek ten powstaje automatycznie w momencie uruchomienia
programu. Jak dot d zaniedbywali my istnienie w tku g ównego, ale w tym przyk adzie prze-
konasz si , e mo na si nim pos ugiwa tak jak ka dym innym w tkiem.
1. Utwórz plik o nazwie UseMain.java.
2. Dost p do w tku g ównego wymaga uzyskania obiektu typu Thread reprezentuj cego
ten w tek. W tym celu wywo amy metod currentThread() zadeklarowan jako static
w klasie Thread. Jej ogóln posta przedstawi em poni ej:
static Thread currentThread()
Metoda ta zwraca referencj w tku, w którym zosta a wywo ana. Zatem je li wywo amy
j w g ównym w tku, otrzymamy referencj g ównego w tku. Dysponuj c t referencj ,
mo emy kontrolowa dzia anie g ównego w tku w taki sam sposób jak innych w tków.
3. Wprowad w pliku tekst ród owy programu przedstawiony na listingu 11.12. Program
ten pobiera referencj w tku g ównego, a nast pnie zmienia jego nazw i priorytet.
Listing 11.12. UseMain.java
/*
Przyk ad 11.2
Sterowanie w tkiem g ównym.
*/
class UseMain {
public static void main(String args[]) {
Thread thrd;
// Pobiera referencj w tku g ównego.
thrd = Thread.currentThread();
// Wy wietla nazw w tku g ównego.
System.out.println("Nazwa w tku g ównego: " +
thrd.getName());
Poleć książkę
Kup książkę
Rozdzia 11. Programowanie wielow tkowe 397
// Wy wietla priorytet w tku g ównego.
System.out.println("Priorytet w tku g ównego: " +
thrd.getPriority());
System.out.println();
// Konfiguruje nazw i priorytet w tku g ównego.
System.out.println("Zmieniam nazw i priorytet w tku g ównego.\n");
thrd.setName("W tek nr 1");
thrd.setPriority(Thread.NORM_PRIORITY+3);
System.out.println("Aktualna nazwa w tku g ównego: " +
thrd.getName());
System.out.println("Bie cy priorytet w tku g ównego: " +
thrd.getPriority());
}
}
4. Poni ej przedstawi em wynik dzia ania tego programu:
Nazwa w tku g ównego: main
Priorytet w tku g ównego: 5
Zmieniam nazw i priorytet w tku g ównego.
Aktualna nazwa w tku g ównego: W tek nr 1
Bie cy priorytet w tku g ównego: 8
5. Wykonuj c operacje na w tku g ównym, powiniene zachowa ostro no . Na przyk ad:
je li umie cisz na ko cu metody main() kod przedstawiony poni ej, to program nigdy
nie zako czy swojego dzia ania, poniewa b dzie oczekiwa na zako czenie w tku
g ównego!
try {
thrd.join();
} catch(InterruptedException exc) {
System.out.println("W tek przerwany");
}
Test sprawdzaj cy
1. W jaki sposób wielow tkowo w Javie umo liwia tworzenie efektywniejszych
programów?
2. Wielow tkowo w Javie opiera si na klasie _____________ i interfejsie
_____________.
3. Dlaczego czasami, tworz c w tki, lepiej jest utworzy klas pochodn klasy Thread,
ni implementowa interfejs Runnable?
4. Poka , jak u y metody join() do oczekiwania na zako czenie w tku MyThrd.
Poleć książkę
Kup książkę
398 Java. Przewodnik dla pocz tkuj cych
5. Zwi ksz priorytet w tku MyThrd o trzy poziomy ponad normalny.
6. Na czym polega efekt dodania s owa kluczowego synchronized w deklaracji metody?
7. Metod wait() i notify() u ywamy do _____________.
8. Zmodyfikuj klas TickTock w taki sposób, aby rzeczywi cie symulowa a up yw czasu.
Zatem niech ka dy  tik trwa pó sekundy, podobnie  tak . Ka dy tik-tak zajmie
zatem jedn sekund (nie przejmuj si czasem potrzebnym na prze czenie w tku).
9. Dlaczego w nowych programach nie nale y u ywa metod suspend(), resume() i stop()?
10. Jaka metoda klasy Thread zwraca nazw w tku?
11. Co zwraca metoda isAlive()?
12. Spróbuj samodzielnie wprowadzi synchronizacj w klasie Queue stworzonej
w poprzednich rozdzia ach w taki sposób, aby zapewni jej bezpieczne u ycie w wielu
w tkach.
Poleć książkę
Kup książkę
Skorowidz
biblioteka Swing, 464, 491
A
bit, 176
abstrakcyjna klasa bazowa, 284
bitowe operatory przypisania, 181
adnotacje, 400, 422
blok
ogólnego przeznaczenia, 424
finally, 309, 332
znacznikowe, 424
kodu, 43
algorytm sortowania Quicksort, 212, 216
static, 215
anonimowa klasa wewn trzna, 221, 521
synchronized, 384
API, Application Programming Interface, 279
try, 299, 304, 312, 332
aplet, 22, 464, 467
blokada, 381
bazuj cy na AWT, 470
b d
MySwingApplet, 524
otwarcia pliku, 334
obs uguj cy zdarzenia myszy, 483
niejednoznaczno ci, 227, 457
Swing, 522
przekroczenia zakresu, 300
wy wietlaj cy baner, 471
sk adni, 34
aplety
w kodzie programu, 297
architektura, 467
wewn trzne, 297
dzia anie, 469
bufor, 80, 353
parametry, 475
buforowanie wierszy, 80
szkielet, 468
architektura
C
model-delegat, 493
model-widok-nadzorca, 493
cia o metody, 123
z wydzielonym modelem, 493
czas istnienia zmiennej, 62
argument, 127
argument wieloznaczny, 438
D
ASCII, 53, 339
asercje, 488 definiowanie klasy, 32, 117
automatyczne definiowanie pakietu, 270
konwersje typów, 71 deklaracja
opakowywanie, 413, 415, 418 bloku static, 215
wypakowywanie, 413
klasy generycznej, 434
zarz dzanie zasobami, 312, 336
klasy pochodnej, 232
AWT, Abstract Window Toolkit, 464, 492
tablicy, 146, 155
zmiennej, 36
B dekoder, 353
dekrementacja, 42, 65
bajt, 334
delegacja zdarze , 481
bezpiecze stwo, 23, 25
delegat interfejsu u ytkownika, 493
biblioteka klas, 48, 279
destruktor, 140
Poleć książkę
Kup książkę
582 Java. Przewodnik dla pocz tkuj cych
dodawanie konstruktora do klasy, 137 importowanie pakietu, 278
dope nienie do dwóch, 180 inicjalizacja, 90
dost p dynamiczna, 60
do pakietu, 274 obiektu, 206
do pliku, 343 tablic wielowymiarowych, 153
do sk adowych, 190, 232, 273 zmiennej, 59
do sk adowych klasy bazowej, 240 inicjalizator, 62
do systemu, 34 inkrementacja, 42, 65
sekwencyjny, 343 instrukcja
drzewo hierarchii, 579 break, 86, 102
dynamiczne zarz dzanie pami ci , 139 break z etykiet , 104
dynamiczno , 25 continue, 108
dynamiczny wybór metody, 255 continue z etykiet , 108
dziedziczenie, 28, 230, 232, 235, 241 default, 85, 89
dziedziczenie wielobazowe, 232 for, 41
dzielenie przez zero, 68, 185 goto, 104
if, 40, 81
if-else-if, 83
E
import, 277
Eclipse, 29
import static, 422
etykieta, 104
new, 120, 136
etykieta done, 105
package, 270
etykieta jlabContents, 509
println(), 36
return, 124
F
super(), 238
switch, 84, 85, 172
fa szywe przebudzenie, 387
throw, 297
funkcje wirtualne, 256
try, 338
instrukcje
G
iteracji, 79
generowanie wyj tku, 305
skoku, 79
generyczna klasa Queue, 448
wyboru, 79
generyczno , 427
interfejs, 269, 279
graficzny interfejs u ytkownika, 467
ActionListener, 504
Annotation, 423
H AutoCloseable, 336
Closeable, 336
hermetyzacja, 27
Containment, 447
hermetyzowanie tablicy, 192
DataInput, 339
hierarchia
ListSelectionListener, 514
dziedziczenia, 28
ListSelectionModel, 513
klas, 230, 241
MouseListener, 482
wielopoziomowa klas, 244
MouseMotionListener, 482
wyj tków, 296
Queue, 286
zawierania, 494
Runnable, 366
Series, 283
I
interfejsy
IDE, 29 dziedzicz ce, 291
identyfikator, 47 generyczne, 445
implementacja, 279 s uchaczy zdarze , 482
implementacja interfejsu, 281 interpreter kodu bajtowego, 24, 31
import sk adowej Static.out, 422 interpretowalno , 25
import sk adowych statycznych, 400, 420 iteracja, 41
Poleć książkę
Kup książkę
Skorowidz 583
NonIntResultException, 316
J
NumericFns, 435
J2SE, Java 2 Standard Edition, 14
Object, 267
Java API, 279
OutputStreamWriter, 351
Java SE, 15
Pair, 437
JDK, Java Development Kit, 17, 29
PrintWriter, 349
j zyk C i C++, 21
Pwr, 143
j zyk C#, 22
Queue, 158, 194, 207, 448
JFC, Java Foundation Classes, 492
Quicksort, 217
JIT, just-in-time, 24
RandomAccessFile, 343
JVM, Java Virtual Machine, 24
Reader, 352
RuntimeException, 313
K
Scanner, 360
ShowBits, 182, 221
kana , 353
SimpleApplet, 465
klasa, 27, 115
String, 167
ActionEvent, 503, 504
StringBuffer, 171
Applet, 477
Summation, 445
ArithmeticException, 300
Sup, 256
Book, 274
System, 48, 279, 326
BookDemo, 274
Thread, 365, 374
BufferedReader, 348, 352
Throwable, 296, 307, 315
ByThrees, 283
TickTock, 389
ByTwos, 281
Timer, 212
CircularQueue, 287
Triangle, 233, 250
Component, 470, 495
TwoDShape, 231, 250, 264
Console, 345
Vehicle, 119
Container, 495
Writer, 351
DataInputStream, 339
klasy
DataOutputStream, 339
abstrakcyjne, 260
Error, 296
bazowe, 229
ErrorInfor, 199
generyczne, 428
ErrorMsg, 265
komponentów Swing, 495
Exception, 296
nadrz dne, 28
FailSoftArray, 192
NIO, 353
FileInputStream, 330
opakowuj ce, 353 355
FileOutputStream, 330, 334
pochodne, 229, 232
FileReader, 351
pochodne klasy Exception, 315
FileWriter, 350
pochodne klasy Thread, 370
GenericMethodDemo, 443
strumieni bajtowych, 325
Help, 130
strumieni znakowych, 326
InputStream, 328
wewn trzne, 219, 521
InputStreamReader, 352
zagnie d one, 218
ItemEvent, 509
zagnie d one static, 222
JApplet, 522
zdarze , 481
java.lang.Enum, 406
klauzula
JButton, 506
case, 85
JCheckBox, 509
catch, 298, 302, 312
JComponent, 494
else, 81
JList, 512
extends, 435, 440
JTextField, 506
finally, 309
ListSelectionEvent, 513
implements, 281
Math, 53, 420
throws, 311
MyThread, 367, 395
throws java.io.IOException, 80
Poleć książkę
Kup książkę
584 Java. Przewodnik dla pocz tkuj cych
kod bajtowy, 24

koder, 353
a cuch wyj tków, 315
kodowanie, 31
a cuch znaków, 58, 167
kolejka, 158
kolejka cykliczna, 288
M
kolejka dynamiczna, 286
komentarz, 32
maszyna wirtualna Java, 24
dokumentacyjny, 573, 578
mened er
jednowierszowy, 33
BorderLayout, 501
wielowierszowy, 32
FlowLayout, 504, 505
kompilator, 28
uk adu, 496
kompilator javac, 31, 32
metadane, 422
kompilator JIT, 24
metoda, 27, 33, 122
kompilowanie programu, 24, 31
metoda
komponent
abs(), 205
JButton, 502
absEqual(), 438
JCheckBox, 509
actionPerformed(), 509
JList, 512
addActionListener(), 506, 521
JTextField, 506
area(), 261
komponenty Swing, 494
charAt(), 171
komunikacja mi dzyw tkowa, 386
close(), 331, 334
konsola znakowa, 80
compareTo(), 355, 406
konstruktor, 135
console(), 345
domy lny, 238
destroy(), 470
generyczny, 445
doubleValue(), 414, 435
klasy bazowej, 235, 238
finalize(), 139
klasy Queue, 207
floatValue(), 414
klasy Thread, 369
generator(), 141
klasy Throwable, 315
generyczna arraysEqual(), 443
klasy Triangle, 236
genException(), 307
klasy TwoDShape, 237
get(), 286
MyClass(), 206
getActionCommand(), 503
o jednym parametrze, 238
getClass(), 267
Transport(), 405
getContentPane(), 500
TwoDShape(), 252
getErrorInfo(), 199
typu wyliczeniowego, 404
getErrorMsg(), 199
z parametrem, 136
getob(), 430
kontekst graficzny, 465
getParameter(), 475
kontener JApplet, 522
getSelectedIndex(), 513
kontener JFrame, 522
getSelectedIndices(), 514
kontenery szczytowe, 495
getSpeed(), 405
konwersja typów w wyra eniach, 76
getText(), 506
konwersja typu, 71
init(), 469, 485
kopiowanie pliku, 335
invokeAndWait(), 501, 502
kopiowanie tablicy, 158
invokeLater(), 501, 502
isAlive(), 375
L
isFactor(), 128
join(), 375
LIFO, last-in, first-out, 28
main(), 33
lista argumentów o zmiennej d ugo ci, 221
makeGUI(), 524
lista JList, 512
Math.abs(), 438
litera y, 56
Math.pow(), 420
a cuchowe, 58
mouseClicked(), 482
znakowe, 59
mouseDragged(), 482
Poleć książkę
Kup książkę
Skorowidz 585
mouseEntered(), 482 dost powe dla sk adowych prywatnych, 233
mouseExited(), 482 generyczne, 443
mouseMoved(), 482 klasy Applet, 477
noChange(), 197 klasy InputStream, 327
notify(), 386 klasy Object, 267
notifyAll(), 386 klasy OutputStream, 328
ordinal(), 406 klasy Reader, 346
ovlDemo(), 202 klasy Thread, 365
paint(), 465, 470 klasy Throwable, 308
parseDouble(), 354 klasy Writer, 347
print(), 37, 349 konwersji a cuchów, 354
println(), 34, 37, 349, 352 natywne, 488
printStackTrace(), 308 o zmiennej liczbie argumentów, 222
prompt(), 311 rekurencyjne, 210
put(), 286 p cherzykowego, 216
range(), 122 wej cia klasy DataInputStream, 340
read(), 80, 328 wyj cia klasy DataOutputStream, 339
readLine(), 348 model, 493
readPassword(), 345 model delegacji zdarze , 479
reciprocal(), 435 modyfikator
removeActionListener(), 506 abstract, 261
removeKeyListener(), 480 dost pu, 33
repaint(), 470 final, 312
resume(), 392 private, 33, 191, 194, 232
run(), 366, 393 protected, 190, 275
setActionCommand(), 506, 508 public, 33, 190
setCharAt(), 171 transient, 486
setName(), 369 volatile, 486
setPriority(), 378 modyfikatory dost pu, 190
show(), 253 monitor, 381
showStatus(), 475
showType(), 431
N
sleep(), 367
nadzorca, 493
sqrt(), 53, 214
najm odszy bit, 180
start(), 469
narzut, 420
static, 214
nawias klamrowy, 34
stop(), 392
nawiasy, 77
substring(), 171
nazwa
sumArray(), 384
klasy, 138
suspend(), 392
obiektu, 118
System.console(), 345
pliku ród owego, 30
tick(), 387
NetBeans, 29
tock(), 387
niejednoznaczno , 226
toString(), 308, 414
niezale no , 25
update(), 471
niezawodno , 25
valueChanged(), 514
values(), 403
O
valuesOf(), 403
vaTest(), 223
obiekt, 27, 116
vaTest(int ...), 227
ActionEvent, 503
wait(), 386, 391
klasy String, 167
write(), 334
przekazywany metodzie, 195
metody
System.err, 327
abstrakcyjne, 261, 279
System.in, 327
Poleć książkę
Kup książkę
586 Java. Przewodnik dla pocz tkuj cych
obiekt operatory
System.out, 327 arytmetyczne, 64
Thread, 369 bitowe, 175
typu Integer, 431 logiczne, 66, 67
typu T, 437 logiczne warunkowe, 67
zablokowany, 381 przesuni cia bitów, 180
obiektowo , 25 relacyjne, 40, 66
obliczanie silni, 210 skrótowe przypisania, 70
obs uga z o one przypisania, 70
b dów, 301, 317
b dów wej cia-wyj cia, 331
P
plików, 350
pakiet, 190, 269
wej cia konsoli, 328
AWT, 465, 477
wyj tków, 295
bookpack, 272, 273
wyj cia konsoli, 329, 349
bookpackext, 275, 276
zdarze , 479
java, 279
zdarze myszy, 482
java.awt, 504
odczyt konsoli, 345
java.awt.event, 479, 504
odczyt z pliku, 330
java.io, 312, 324
odczyt znaków, 346
java.lang, 279
odst py, 77
java.lang.annotation, 423
odwo anie do obiektu, 120
javax, 494
odzyskiwanie nieu ytków, 139
javax.swing.event, 513
ogólna klasa akcji, 28
mypack, 271
ograniczanie argumentów wieloznacznych, 440
NIO, 353
ograniczanie typów, 434
Swing, 324, 493
ograniczenia dla sk adowych statycznych, 458
pakiety Java API, 279
ograniczenia tablic generycznych, 459
panel szklany, 495
ograniczenia zwi zane z wyj tkami, 460
panel warstw, 495
okno
panel zawarto ci, 495
apletu SimpletApplet, 466
parametr, 33, 127
programu ListDemo, 515
parametr T, 430
programu SwingFC, 516
parametry apletów, 475
programu TFDemo, 508
p tla
statusu, 475
do-while, 97
opakowywanie, 414
for, 41, 90, 92, 162
opcja classpath, 271
for rozszerzona, 166
operacja bitowa z operatorem przypisania, 181
for-each, 162, 163
operacja get, 159
while, 96
operacja put, 159
p tle
operacje na a cuchach, 168
bez cia a, 94
operator, 63
niesko czone, 94
?, 184
zagnie d one, 112
+, 36
plik
bitowy AND, 175
Banner.java, 471
bitowy NOT, 179
BookDemo.java, 272
bitowy OR, 177
Bubble.java, 149
bitowy XOR, 178
CompFiles.java, 341
delete, 139
Example.class, 31
diamentowy, 456
Example.java, 30
instanceof, 486
ExtendThread.java, 371
new, 120, 138, 146
Finalize.java, 140
przypisania, 69, 121
GalToLit.java, 39
ternarny, 184
GalToLitTable.java, 45
Poleć książkę
Kup książkę
Skorowidz 587
GenQDemo.java, 450 argumentów w gór , 247
Help.java, 88, 99 argumentu przez referencj , 197
Help3.java, 109 argumentu przez warto , 197
HelpClassDemo.java, 130 obiektów, 195
ICharQ.java, 286 przeno no , 23, 25
IGenQ.java, 448 przerwanie programu, Ctrl+C, 391
IQDemo.java, 288 przerywanie p tli, 102
LogicalOpTable.java, 74 przes anianie metod, 252, 255
QDemo.java, 159 przes anianie metod w klasie TwoDShape, 257
QDemo2.java, 207 przes anianie nazw, 63
QExcDemo.java, 317 przestrze nazw, 270
QSDemo.java, 216 przypisanie, 120
ShowBitsDemo.java, 182 przypisywanie referencji tablic, 155
Sound.java, 55 pusta instrukcja, 94
SwingFC.java, 516
TrafficLigthDemo.java, 408
R
TruckDemo.java, 242
referencje, 120
UseMain.java, 396
interfejsu, 284
VehicleDemo.class, 118
klasy bazowej, 248
VehicleDemo.java, 118
obiektów klas pochodnych, 250
pliki
tablicy, 155
.class, 270
rekurencja, 210
HTML, 466
r czne opakowywanie i wypakowywanie, 415
o dost pie swobodnym, 343
rozproszono , 25
pomocy, 356
rozszerzenie .class, 31
ród owe, 30
rozszerzenie .java, 30
polimorfizm, 28, 204
rzutowanie, 442
pomoc, 130, 355
rzutowanie typów, 72
porównywanie plików, 341, 516
posta binarna, 176
S
priorytet operatorów, 74
priorytet w tku, 378
schemat klasy Triangle, 231
proces hermetyzacji, 414
schemat tablicy, 147
program, 30
sekwencje specjalne, 57
appletviewer, 465, 522
sekwencje znaków, 57
CopyFile, 337
selektor, 353
do zamiany liter, 176
separator, 44
javadoc, 579
serwlet, 25
SwingDemo, 498
sk adnia (...), 226
sygnalizacji wietlnej, 408
sk adowa length, 156
szyfruj cy, 178
sk adowa protected, 275, 278
wielow tkowy, 363
sk adowa prywatna, 192
programowanie
sk adowe klasy, 27
obiektowe, 26
s owo kluczowe, 47
równoleg e, 386
assert, 487
strukturalne, 26
class, 116
przechwytywanie
enum, 403
wyj tków, 300
extends, 230, 291
wyj tków klas pochodnych, 303
false, 47
wyj tków klasy bazowej, 303
final, 264
przeci anie konstruktorów, 205
finally, 309
przeci anie metod, 201, 204, 225
import, 420
przekazywanie
instanceof, 487
argumentów, 196
interface, 280, 423
Poleć książkę
Kup książkę
588 Java. Przewodnik dla pocz tkuj cych
s owo kluczowe jednowymiarowe, 146
native, 488 a cuchów, 170
null, 47 nieregularne, 152
public, 33 tablic, 165
static, 33, 212, 420 typu T, 460
strictfp, 487
wielowymiarowe, 153
super, 237, 240, 253
technologia HotSpot, 24
synchronized, 381
terminologia Javy, 25
this, 142, 240, 489
tryb SINGLE_SELECTI, 513
transient, 486
tworzenie
true, 47
adnotacji, 423
try i catch, 297
aplikacji Swing, 497, 522
void, 33
instancji T, 458
volatile, 486
a cuchów, 167
s uchacz, 480
obiektu, 117
specyfikacja zasobu, 336
przycisku, 503
sta a final, 266
w tku, 365
sta e w asnego typu, 400
wielu w tków, 372
sta e wspó dzielone, 291
typ
sta e wyliczeniowe, 400, 401
interfejsu generycznego, 447
sterowanie cyklem wykonania apletu, 468
logiczny, 54
sterowanie instrukcj switch, 172
surowy, 452
stos, 28, 158
surowy klasy generycznej, 453
strumie , 324
wyliczeniowy, 404
bajtowy, 324, 345
zmiennej, 36
b dów, 327
zmiennej referencyjnej, 250
InputStream, 339
typy
InputStreamReader, 345
ca kowite, 51
predefiniowany, 327
danych, 37, 50
wej cia, 324, 328
generyczne, 413, 432
wyj cia, 324, 327
ogólne, 267
znakowy, 324, 345
opakowuj ce, 414
znakowy FileReader, 352
podstawowe, 139
znakowy FileWriter, 351
zmiennoprzecinkowe, 52
znakowy PrintWriter, 349
sygnatura, 205
U
synchronizacja, 364, 380
dost pu do metody, 381
Unicode, 53
dost pu do obiektu, 381
ustawianie bitu, 176
instrukcji, 384
metod, 381, 384
W
system ósemkowy, 57
system pomocy, 355 warto null, 348
system szesnastkowy, 57
warto porz dkowa, 407
szkielet apletu, 468
warto zmiennych, 62
w tek, 363
g ówny, 365, 369, 396

gotowy do wykonywania, 364
cie ka dost pu do katalogu, 271
ko cz cy dzia anie, 376, 392
rednik, 44
potomny, 375
priorytet, 378
T
rozdzia u zdarze , 501
tabela prawdy, 74 wstrzymuj cy dzia anie, 392
tablice, 145 wykonywany, 364
dwuwymiarowe, 151 wznawiaj cy dzia anie, 392
Poleć książkę
Kup książkę
Skorowidz 589
zablokowany, 364
zakleszczenie, 392
zako czony, 364
zamkni cie pliku, 332
zawieszony, 364
zamykanie automatyczne pliku, 336
wczytywanie a cuchów, 348
zapis danych, 329
widok, 493
zapis w pliku, 334
wielow tkowo , 25, 364, 396
zapis znaków w pliku, 350
wielozadaniowo , 364
zapobieganie dziedziczeniu, 265
wiersz wywo ania, 173
zapobieganie przes anianiu, 264
wnioskowanie typów, 456
zasi g deklaracji, 95
wska nik, 26
zasi g deklaracji zmiennych, 60
wska nik zawarto ci pliku, 343
zbiór znaków, 353
wycieki pami ci, 331
zdarzenia, 479
wyj tek, 295
klasy, 480
ArithmeticException, 301, 313
model delegacji, 481
ArrayIndexOutOfBoundsException, 149, 298, 300,
s uchacze, 480
304, 313
ród a, 479
AssertionError, 487
zdarzenie ListSelectionEvent, 513, 514
FileNotFoundException, 334
zintegrowane rodowisko programisty, 29
IOException, 311, 328
zmienna, 27, 35, 59
wyj tki
final, 406
niesprawdzane, 314
iteracyjna, 162, 165
sprawdzane, 314
minivan, 120
w klasie Queue, 317
referencyjna, 248, 285
wbudowane w Jav , 313
steruj ca, 93
wyliczanie warto ci, 220
rodowiskowa CLASSPATH, 271
wyliczenie, 400
zmienne interfejsu, 280
wymazywanie, 457
znacznik APPLET, 465
wyra enia, 75
znacznik OBJECT, 466
wy cig, 392
znaczniki javadoc, 573
wywo anie
znak +, 36
konstruktora klasy bazowej, 237
znak komentarza, 277
super.show(), 254
znaki, 53
System.in.read(), 80
zwracanie obiektów, 199
this(), 489
zwracanie warto ci, 125
konstruktorów, 247

Z
ród a zdarze , 479
zagnie d anie
bloków, 62
bloków try, 304
instrukcji if, 82
instrukcji switch, 88
zasi gów, 61
Poleć książkę
Kup książkę
590 Java. Przewodnik dla pocz tkuj cych
Poleć książkę
Kup książkę