Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00000 003810 19001233 na godz. na dobę w sumie
Java 9. Przewodnik doświadczonego programisty. Wydanie II - książka
Java 9. Przewodnik doświadczonego programisty. Wydanie II - książka
Autor: Liczba stron: 464
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4250-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> inne - programowanie
Porównaj ceny (książka, ebook, audiobook).

Dziś Java jest uważana za starannie zaprojektowany i wciąż rozwijany język, który stanowi standard w wielu potężnych korporacjach z branży IT. W język ten wbudowano funkcje ułatwiające implementację wielu złożonych zadań programistycznych. W nowej wersji Javy znalazło się wiele usprawnień dotyczących najbardziej podstawowych technologii platformy Java. Nowe mechanizmy, na przykład modularyzacja czy nowe podejście do programowania współbieżnego, poprawią efektywność pracy programisty. Jednak opanowanie tak potężnego narzędzia i używanie go na profesjonalnym poziomie stało się prawdziwym wyzwaniem.

Ta książka jest kompletnym i zwięzłym kompendium praktycznego wykorzystania Javy. Została pomyślana w taki sposób, aby nauka języka i bibliotek odbywała się możliwie szybko. Omówiono tu bardzo dużo materiału, ale jego uporządkowanie i sposób prezentacji ułatwiają szybki dostęp do danego zagadnienia i łatwe zrozumienie treści. Dzięki temu płynnie nauczysz się wszystkich nowości, od systemu modułów „Project Jigsaw” do wyrażeń lambda czy strumieni. Opanujesz tajniki programowania współbieżnego dzięki potężnym mechanizmom dostępnym w bibliotekach. Docenisz tę książkę, jeśli profesjonalnie piszesz aplikacje w Javie, zwłaszcza jeżeli chcesz tworzyć oprogramowanie działające po stronie serwera lub w systemie Android.

Najważniejsze zagadnienia:

Mistrz Javy — to tak dumnie brzmi!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Core Java SE 9 for the Impatient (2nd Edition) Tłumaczenie: Andrzej Stefański ISBN: 978-83-283-4250-7 Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Authorized translation from the English language edition, entitled: CORE JAVA SE 9 FOR THE IMPATIENT, Second Edition; ISBN 0134694724; by Cay S. Horstmann; published by Pearson Education, Ine, publishing as Addison-Wesley Professional. Copyright ©2018 by Pearson Education, Inc. 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 Pearson Edueation, Inc.Polish language edition published by HELION S.A. Copyright ©2018. Screenshots of Eclipse. Published by The Eclipse Foundation. Screenshots of Java. Published by Oracle. 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ądź 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. Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/jav9p2.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jav9p2 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:202)ci Wst(cid:194)p ........................................................................................................................................................15 Podzi(cid:194)kowania .........................................................................................................................................17 O autorze ..................................................................................................................................................19 1.1. Rozdzia(cid:196) 1. Podstawowe struktury programistyczne ...........................................................................21 Nasz pierwszy program ................................................................................... 22 1.1.1. Analiza programu „Witaj, (cid:264)wiecie!” ...................................................... 22 1.1.2. Kompilacja i uruchamianie programu w j(cid:246)zyku Java ............................... 24 1.1.3. Wywo(cid:228)ania metod ............................................................................... 26 1.1.4. JShell ................................................................................................ 27 1.2. Typy proste ........................................................................................................... 31 1.2.1. Typy ca(cid:228)kowite ze znakiem .................................................................. 31 1.2.2. Typy zmiennoprzecinkowe ................................................................... 32 1.2.3. Typ char ............................................................................................ 33 1.2.4. Typ boolean ....................................................................................... 33 1.3. Zmienne ............................................................................................................... 34 1.3.1. Deklaracje zmiennych ......................................................................... 34 1.3.2. Nazwy ............................................................................................... 34 1.3.3. Inicjalizacja ........................................................................................ 35 1.3.4. Sta(cid:228)e ................................................................................................. 35 1.4. Dzia(cid:228)ania arytmetyczne .......................................................................................... 36 1.4.1. Przypisanie ........................................................................................ 37 1.4.2. Podstawowa arytmetyka ..................................................................... 37 1.4.3. Metody matematyczne ........................................................................ 39 1.4.4. Konwersja typów liczbowych ................................................................ 40 1.4.5. Operatory relacji i operatory logiczne .................................................... 41 1.4.6. Du(cid:276)e liczby ........................................................................................ 43 1.5. Ci(cid:241)gi znaków ......................................................................................................... 43 1.5.1. (cid:227)(cid:241)czenie ci(cid:241)gów znaków ..................................................................... 43 1.5.2. Wycinanie ci(cid:241)gów znaków ................................................................... 44 1.5.3. Porównywanie ci(cid:241)gów znaków ............................................................. 45 1.5.4. Konwersja liczb na znaki i znaków na liczby .......................................... 46 Poleć książkęKup książkę 6 Java 9. Przewodnik do(cid:202)wiadczonego programisty 1.5.5. API klasy String .................................................................................. 47 1.5.6. Kodowanie znaków w j(cid:246)zyku Java ........................................................ 48 1.6. Wej(cid:264)cie i wyj(cid:264)cie ................................................................................................... 50 1.6.1. Wczytywanie danych wej(cid:264)ciowych ........................................................ 51 1.6.2. Formatowanie generowanych danych ................................................... 52 1.7. Kontrola przep(cid:228)ywu ................................................................................................ 54 1.7.1. Instrukcje warunkowe ......................................................................... 54 1.7.2. P(cid:246)tle ................................................................................................. 56 1.7.3. Przerywanie i kontynuacja ................................................................... 57 1.7.4. Zasi(cid:246)g zmiennych lokalnych ................................................................ 59 1.8. Tablice i listy tablic ................................................................................................ 60 1.8.1. Obs(cid:228)uga tablic ................................................................................... 60 1.8.2. Tworzenie tablicy ................................................................................ 61 1.8.3. Klasa ArrayList ................................................................................... 62 1.8.4. Klasy opakowuj(cid:241)ce typy proste ............................................................ 63 1.8.5. Rozszerzona p(cid:246)tla for ......................................................................... 64 1.8.6. Kopiowanie tablic i obiektów ArrayList ................................................. 64 1.8.7. Algorytmy tablic .................................................................................. 65 1.8.8. Parametry wiersza polece(cid:254) ................................................................. 66 1.8.9. Tablice wielowymiarowe ...................................................................... 67 1.9. Dekompozycja funkcjonalna ................................................................................... 69 1.9.1. Deklarowanie i wywo(cid:228)ywanie metod statycznych .................................... 69 1.9.2. Parametry tablicowe i zwracane warto(cid:264)ci .............................................. 70 1.9.3. Zmienna liczba parametrów ................................................................ 70 (cid:231)wiczenia .................................................................................................................... 71 Rozdzia(cid:196) 2. Programowanie obiektowe .................................................................................................73 2.1. Praca z obiektami .................................................................................................. 74 2.1.1. Metody dost(cid:246)powe i modyfikuj(cid:241)ce ....................................................... 76 2.1.2. Referencje do obiektu ........................................................................ 76 2.2. Implementowanie klas ........................................................................................... 78 2.2.1. Zmienne instancji ............................................................................... 78 2.2.2. Nag(cid:228)ówki metod ................................................................................. 79 2.2.3. Tre(cid:264)ci metod ..................................................................................... 79 2.2.4. Wywo(cid:228)ania metod instancji .................................................................. 80 2.2.5. Referencja this .................................................................................. 80 2.2.6. Wywo(cid:228)anie przez warto(cid:264)(cid:232) .................................................................... 81 2.3. Tworzenie obiektów ............................................................................................... 82 2.3.1. Implementacja konstruktorów ............................................................. 82 2.3.2. Przeci(cid:241)(cid:276)anie ...................................................................................... 83 2.3.3. Wywo(cid:228)ywanie jednego konstruktora z innego ......................................... 84 2.3.4. Domy(cid:264)lna inicjalizacja ........................................................................ 84 2.3.5. Inicjalizacja zmiennych instancji .......................................................... 85 2.3.6. Zmienne instancji z modyfikatorem final .............................................. 85 2.3.7. Konstruktor bez parametrów ............................................................... 86 2.4. Statyczne zmienne i metody ................................................................................... 87 2.4.1. Zmienne statyczne ............................................................................. 87 2.4.2. Sta(cid:228)e statyczne .................................................................................. 87 2.4.3. Statyczne bloki inicjalizacyjne .............................................................. 88 2.4.4. Metody statyczne ............................................................................... 89 2.4.5. Metody wytwórcze .............................................................................. 90 Poleć książkęKup książkę Spis tre(cid:202)ci 7 2.5. Pakiety ................................................................................................................. 90 2.5.1. Deklarowanie pakietów ....................................................................... 91 2.5.2. Polecenie jar ...................................................................................... 92 2.5.3. (cid:263)cie(cid:276)ka przeszukiwa(cid:254) dla klas ............................................................ 93 2.5.4. Dost(cid:246)p do pakietu ............................................................................. 94 Importowanie klas .............................................................................. 95 2.5.5. 2.5.6. Import metod statycznych ................................................................... 96 2.6. Klasy zagnie(cid:276)d(cid:276)one ............................................................................................... 97 2.6.1. Statyczne klasy zagnie(cid:276)d(cid:276)one .............................................................. 97 2.6.2. Klasy wewn(cid:246)trzne .............................................................................. 98 2.6.3. Specjalne regu(cid:228)y sk(cid:228)adni dla klas wewn(cid:246)trznych .................................. 100 2.7. Komentarze do dokumentacji ............................................................................... 101 2.7.1. Wstawianie komentarzy .................................................................... 102 2.7.2. Komentarze klasy ............................................................................ 102 2.7.3. Komentarze metod ........................................................................... 103 2.7.4. Komentarze zmiennych ..................................................................... 103 2.7.5. Ogólne komentarze .......................................................................... 103 2.7.6. Odno(cid:264)niki ........................................................................................ 104 2.7.7. Opisy pakietów, modu(cid:228)ów i ogólne ..................................................... 105 2.7.8. Wycinanie komentarzy ...................................................................... 105 (cid:231)wiczenia .................................................................................................................. 106 Rozdzia(cid:196) 3. Interfejsy i wyra(cid:209)enia lambda ...........................................................................................109 3.1. Interfejsy ............................................................................................................ 110 3.1.1. Deklarowanie interfejsu .................................................................... 110 3.1.2. Implementowanie interfejsu .............................................................. 111 3.1.3. Konwersja do typu interfejsu ............................................................. 113 3.1.4. Rzutowanie i operator instanceof ...................................................... 113 3.1.5. Rozszerzanie interfejsów ................................................................... 114 3.1.6. Implementacja wielu interfejsów ........................................................ 114 3.1.7. Sta(cid:228)e ............................................................................................... 114 3.2. Metody statyczne, domy(cid:264)lne i prywatne ................................................................. 115 3.2.1. Metody statyczne ............................................................................. 115 3.2.2. Metody domy(cid:264)lne ............................................................................. 116 3.2.3. Rozstrzyganie konfliktów metod domy(cid:264)lnych ....................................... 116 3.2.4. Metody prywatne .............................................................................. 118 3.3. Przyk(cid:228)ady interfejsów ........................................................................................... 118 Interfejs Comparable ........................................................................ 118 3.3.1. Interfejs Comparator ........................................................................ 120 3.3.2. 3.3.3. Interfejs Runnable ............................................................................ 121 3.3.4. Wywo(cid:228)ania zwrotne interfejsu u(cid:276)ytkownika .......................................... 121 3.4. Wyra(cid:276)enia lambda ............................................................................................... 122 3.4.1. Sk(cid:228)adnia wyra(cid:276)e(cid:254) lambda ................................................................. 123 3.4.2. Interfejsy funkcyjne .......................................................................... 124 3.5. Referencje do metod i konstruktora ...................................................................... 125 3.5.1. Referencje do metod ........................................................................ 125 3.5.2. Referencje konstruktora ................................................................... 126 3.6. Przetwarzanie wyra(cid:276)e(cid:254) lambda ............................................................................. 127 3.6.1. Implementacja odroczonego wykonania ............................................. 127 3.6.2. Wybór interfejsu funkcjonalnego ........................................................ 128 Implementowanie w(cid:228)asnych interfejsów funkcjonalnych ....................... 130 3.6.3. Poleć książkęKup książkę 8 Java 9. Przewodnik do(cid:202)wiadczonego programisty 3.7. Wyra(cid:276)enia lambda i zasi(cid:246)g zmiennych ................................................................... 131 3.7.1. Zasi(cid:246)g zmiennej lambda ................................................................... 131 3.7.2. Dost(cid:246)p do zmiennych zewn(cid:246)trznych ................................................... 131 3.8. Funkcje wy(cid:276)szych rz(cid:246)dów ..................................................................................... 134 3.8.1. Metody zwracaj(cid:241)ce funkcje ............................................................... 134 3.8.2. Metody modyfikuj(cid:241)ce funkcje ............................................................ 134 3.8.3. Metody interfejsu Comparator ........................................................... 135 3.9. Klasy lokalne i anonimowe ................................................................................... 136 3.9.1. Klasy lokalne ................................................................................... 136 3.9.2. Klasy anonimowe ............................................................................. 137 (cid:231)wiczenia .................................................................................................................. 137 Rozdzia(cid:196) 4. Dziedziczenie i mechanizm refleksji ...................................................................................141 4.1. Rozszerzanie klas ................................................................................................ 142 4.1.1. Klasy nadrz(cid:246)dne i podrz(cid:246)dne ............................................................ 142 4.1.2. Definiowanie i dziedziczenie metod klas podrz(cid:246)dnych .......................... 143 4.1.3. Przes(cid:228)anianie metod ......................................................................... 143 4.1.4. Tworzenie klasy podrz(cid:246)dnej ............................................................... 145 4.1.5. Przypisania klas nadrz(cid:246)dnych ............................................................ 145 4.1.6. Rzutowanie ...................................................................................... 146 4.1.7. Metody i klasy z modyfikatorem final ................................................. 146 4.1.8. Abstrakcyjne metody i klasy .............................................................. 147 4.1.9. Ograniczony dost(cid:246)p .......................................................................... 148 4.1.10. Anonimowe klasy podrz(cid:246)dne ............................................................. 149 4.1.11. Dziedziczenie i metody domy(cid:264)lne ....................................................... 149 4.1.12. Wywo(cid:228)ania metod z super ................................................................. 150 4.2. Object — najwy(cid:276)sza klasa nadrz(cid:246)dna .................................................................... 151 4.2.1. Metoda toString ............................................................................... 151 4.2.2. Metoda equals ................................................................................ 153 4.2.3. Metoda hashCode ............................................................................ 155 4.2.4. Klonowanie obiektów ........................................................................ 156 4.3. Wyliczenia .......................................................................................................... 159 4.3.1. Sposoby wyliczania .......................................................................... 159 4.3.2. Konstruktory, metody i pola .............................................................. 160 4.3.3. Zawarto(cid:264)(cid:232) elementów ....................................................................... 161 4.3.4. Elementy statyczne .......................................................................... 161 4.3.5. Wyra(cid:276)enia switch ze sta(cid:228)ymi wyliczeniowymi ....................................... 162 4.4. Informacje o typie i zasobach w czasie dzia(cid:228)ania programu ..................................... 163 4.4.1. Klasa Class ..................................................................................... 163 4.4.2. Wczytywanie zasobów ....................................................................... 166 4.4.3. Programy wczytuj(cid:241)ce klasy ................................................................ 166 4.4.4. Kontekstowy program wczytuj(cid:241)cy klasy .............................................. 168 4.4.5. Programy do (cid:228)adowania us(cid:228)ug ............................................................ 169 4.5. Refleksje ............................................................................................................ 171 4.5.1. Wyliczanie elementów klasy .............................................................. 171 4.5.2. Kontrolowanie obiektów .................................................................... 172 4.5.3. Wywo(cid:228)ywanie metod ......................................................................... 173 4.5.4. Tworzenie obiektów .......................................................................... 173 4.5.5. JavaBeans ....................................................................................... 174 4.5.6. Praca z tablicami ............................................................................. 175 4.5.7. Klasa Proxy ..................................................................................... 177 (cid:231)wiczenia .................................................................................................................. 178 Poleć książkęKup książkę Spis tre(cid:202)ci 9 Rozdzia(cid:196) 5. Wyj(cid:190)tki, asercje i logi ..........................................................................................................181 5.1. Obs(cid:228)uga wyj(cid:241)tków ................................................................................................ 182 5.1.1. Wyrzucanie wyj(cid:241)tków ........................................................................ 182 5.1.2. Hierarchia wyj(cid:241)tków .......................................................................... 183 5.1.3. Deklarowanie wyj(cid:241)tków kontrolowanych ............................................. 185 5.1.4. Przechwytywanie wyj(cid:241)tków ................................................................ 186 5.1.5. Wyra(cid:276)enie try z okre(cid:264)leniem zasobów ................................................ 187 5.1.6. Klauzula finally ................................................................................. 188 5.1.7. Ponowne wyrzucanie wyj(cid:241)tków i (cid:228)(cid:241)czenie ich w (cid:228)a(cid:254)cuchy ...................... 189 5.1.8. Nieprzechwycone wyj(cid:241)tki i (cid:264)lad stosu wywo(cid:228)a(cid:254) .................................... 191 5.1.9. Metoda Objects.requireNonNull ......................................................... 192 5.2. Asercje ............................................................................................................... 192 5.2.1. U(cid:276)ycie asercji ................................................................................... 193 5.2.2. W(cid:228)(cid:241)czanie i wy(cid:228)(cid:241)czanie asercji ........................................................... 193 5.3. Rejestrowanie danych .......................................................................................... 194 5.3.1. Klasa Logger ................................................................................... 194 5.3.2. Mechanizmy rejestruj(cid:241)ce dane .......................................................... 195 5.3.3. Poziomy rejestrowania danych ........................................................... 195 5.3.4. Inne metody rejestrowania danych ..................................................... 196 5.3.5. Konfiguracja mechanizmów rejestrowania danych ............................... 197 5.3.6. Programy obs(cid:228)uguj(cid:241)ce rejestrowanie danych ....................................... 198 5.3.7. Filtry i formaty .................................................................................. 201 (cid:231)wiczenia .................................................................................................................. 201 Rozdzia(cid:196) 6. Programowanie uogólnione ..............................................................................................205 6.1. Klasy uogólnione ................................................................................................. 206 6.2. Metody uogólnione .............................................................................................. 207 6.3. Ograniczenia typów .............................................................................................. 208 6.4. Zmienno(cid:264)(cid:232) typów i symbole wieloznaczne ............................................................. 209 6.4.1. Symbole wieloznaczne w typach podrz(cid:246)dnych ..................................... 210 6.4.2. Symbole wieloznaczne typów nadrz(cid:246)dnych ......................................... 210 6.4.3. Symbole wieloznaczne ze zmiennymi typami ....................................... 212 6.4.4. Nieograniczone symbole wieloznaczne ............................................... 213 6.4.5. Przechwytywanie symboli wieloznacznych ........................................... 213 6.5. Uogólnienia w maszynie wirtualnej Javy ................................................................. 214 6.5.1. Wymazywanie typów ......................................................................... 214 6.5.2. Wprowadzanie rzutowania ................................................................. 215 6.5.3. Metody pomostowe .......................................................................... 215 6.6. Ograniczenia uogólnie(cid:254) ........................................................................................ 216 6.6.1. Brak typów prostych ......................................................................... 217 6.6.2. W czasie dzia(cid:228)ania kodu wszystkie typy s(cid:241) surowe .............................. 217 6.6.3. Nie mo(cid:276)esz tworzy(cid:232) instancji zmiennych opisuj(cid:241)cych typy .................... 218 6.6.4. Nie mo(cid:276)esz tworzy(cid:232) tablic z parametryzowanym typem ........................ 220 6.6.5. Zmienne opisuj(cid:241)ce typ klasy nie s(cid:241) poprawne w kontek(cid:264)cie statycznym .................................................................. 221 6.6.6. Metody nie mog(cid:241) wywo(cid:228)ywa(cid:232) konfliktów po wymazywaniu typów ........... 221 6.6.7. Wyj(cid:241)tki i uogólnienia ......................................................................... 222 6.7. Refleksje i uogólnienia ......................................................................................... 223 6.7.1. Klasa Class T ............................................................................... 223 Informacje o uogólnionych typach w maszynie wirtualnej ..................... 224 6.7.2. (cid:231)wiczenia .................................................................................................................. 226 Poleć książkęKup książkę 10 Java 9. Przewodnik do(cid:202)wiadczonego programisty Rozdzia(cid:196) 7. Kolekcje ..............................................................................................................................229 7.1. Mechanizmy do zarz(cid:241)dzania kolekcjami ................................................................. 230 7.2. Iteratory ............................................................................................................. 233 7.3. Zestawy .............................................................................................................. 234 7.4. Mapy .................................................................................................................. 236 7.5. Inne kolekcje ...................................................................................................... 238 7.5.1. W(cid:228)a(cid:264)ciwo(cid:264)ci ..................................................................................... 238 7.5.2. Zestawy bitów .................................................................................. 240 7.5.3. Zestawy wyliczeniowe i mapy ............................................................ 241 7.5.4. Stosy, kolejki zwyk(cid:228)e i dwukierunkowe oraz kolejki z priorytetami .......... 241 7.5.5. Klasa WeakHashMap ....................................................................... 242 7.6. Widoki ................................................................................................................ 243 7.6.1. Ma(cid:228)e kolekcje .................................................................................. 243 7.6.2. Zakresy ........................................................................................... 244 7.6.3. Niemodyfikowalne widoki .................................................................. 245 (cid:231)wiczenia .................................................................................................................. 246 Rozdzia(cid:196) 8. Strumienie ..........................................................................................................................249 8.1. Od iteratorów do operacji strumieniowych .............................................................. 250 8.2. Tworzenie strumienia ........................................................................................... 252 8.3. Metody filter, map i flatMap ................................................................................. 253 8.4. Wycinanie podstrumieni i (cid:228)(cid:241)czenie strumieni .......................................................... 254 8.5. Inne przekszta(cid:228)cenia strumieni ............................................................................. 255 8.6. Proste redukcje ................................................................................................... 256 8.7. Typ Optional ....................................................................................................... 257 8.7.1. Jak korzysta(cid:232) z warto(cid:264)ci Optional ...................................................... 257 8.7.2. Jak nie korzysta(cid:232) z warto(cid:264)ci Optional ................................................. 258 8.7.3. Tworzenie warto(cid:264)ci Optional .............................................................. 259 8.7.4. (cid:227)(cid:241)czenie flatMap z funkcjami warto(cid:264)ci Optional .................................. 259 8.7.5. Zamiana Optional w Stream .............................................................. 260 8.8. Kolekcje wyników ................................................................................................ 261 8.9. Tworzenie map .................................................................................................... 262 8.10. Grupowanie i partycjonowanie ............................................................................ 264 8.11. Kolektory strumieniowe ...................................................................................... 264 8.12. Operacje redukcji .............................................................................................. 266 8.13. Strumienie typów prostych ................................................................................. 268 8.14. Strumienie równoleg(cid:228)e ....................................................................................... 269 (cid:231)wiczenia .................................................................................................................. 271 Rozdzia(cid:196) 9. Przetwarzanie danych wej(cid:202)ciowych i wyj(cid:202)ciowych ......................................................273 9.1. Strumienie wej(cid:264)ciowe i wyj(cid:264)ciowe, mechanizmy wczytuj(cid:241)ce i zapisuj(cid:241)ce ................... 274 9.1.1. Pozyskiwanie strumieni ..................................................................... 274 9.1.2. Wczytywanie bajtów .......................................................................... 275 9.1.3. Zapisywanie bajtów .......................................................................... 276 9.1.4. Kodowanie znaków ........................................................................... 276 9.1.5. Wczytywanie danych tekstowych ........................................................ 278 9.1.6. Generowanie danych tekstowych ....................................................... 280 9.1.7. Wczytywanie i zapisywanie danych binarnych ...................................... 281 9.1.8. Pliki o swobodnym dost(cid:246)pie .............................................................. 282 9.1.9. Pliki mapowane w pami(cid:246)ci ................................................................ 282 9.1.10. Blokowanie plików ............................................................................ 283 Poleć książkęKup książkę Spis tre(cid:202)ci 11 9.2. (cid:263)cie(cid:276)ki, pliki i katalogi ......................................................................................... 283 9.2.1. (cid:263)cie(cid:276)ki ............................................................................................ 283 9.2.2. Tworzenie plików i katalogów ............................................................ 285 9.2.3. Kopiowanie, przenoszenie i usuwanie plików ...................................... 286 9.2.4. Odwiedzanie katalogów .................................................................... 287 9.2.5. System plików ZIP ............................................................................ 289 9.3. Po(cid:228)(cid:241)czenia HTTP .................................................................................................. 290 9.3.1. Klasy URLConnection i HttpURLConnection ........................................ 290 9.3.2. API klienta HTTP .............................................................................. 292 9.4. Wyra(cid:276)enia regularne ............................................................................................ 294 9.4.1. Sk(cid:228)adnia wyra(cid:276)e(cid:254) regularnych ............................................................ 294 9.4.2. Odnajdywanie pojedynczego dopasowania .......................................... 298 9.4.3. Odnajdywanie wszystkich dopasowa(cid:254) ................................................ 299 9.4.4. Grupy .............................................................................................. 299 9.4.5. Dzielenie za pomoc(cid:241) znaczników ....................................................... 300 9.4.6. Zast(cid:246)powanie dopasowa(cid:254) ................................................................ 301 9.4.7. Flagi ................................................................................................ 302 9.5. Serializacja ......................................................................................................... 302 9.5.1. Interfejs Serializable ......................................................................... 303 9.5.2. Chwilowe zmienne instancji .............................................................. 304 9.5.3. Metody readObject i writeObject ........................................................ 304 9.5.4. Metody readResolve i writeReplace ................................................... 305 9.5.5. Wersjonowanie ................................................................................ 307 (cid:231)wiczenia .................................................................................................................. 308 Rozdzia(cid:196) 10. Programowanie wspó(cid:196)bie(cid:209)ne ............................................................................................311 10.1. Zadania wspó(cid:228)bie(cid:276)ne ......................................................................................... 312 10.1.1. Uruchamianie zada(cid:254) ......................................................................... 313 10.1.2. Obiekty Future ................................................................................. 314 10.2. Obliczenia asynchroniczne ................................................................................. 316 10.2.1. Klasa CompletableFuture .................................................................. 317 10.2.2. Tworzenie obiektów typu CompletableFuture ...................................... 318 10.2.3. D(cid:228)ugie zadania obs(cid:228)uguj(cid:241)ce interfejs u(cid:276)ytkownika ............................... 321 10.3. Bezpiecze(cid:254)stwo w(cid:241)tków ..................................................................................... 322 10.3.1. Widoczno(cid:264)(cid:232) ..................................................................................... 322 10.3.2. Wy(cid:264)cigi ........................................................................................... 324 10.3.3. Strategie bezpiecznego korzystania ze wspó(cid:228)bie(cid:276)no(cid:264)ci ........................ 326 10.3.4. Klasy niemodyfikowalne .................................................................... 327 10.4. Algorytmy równoleg(cid:228)e ......................................................................................... 328 10.4.1. Strumienie równoleg(cid:228)e ...................................................................... 328 10.4.2. Równoleg(cid:228)e operacje na tablicach ...................................................... 329 10.5. Struktury danych bezpieczne dla w(cid:241)tków ............................................................. 330 10.5.1. Klasa ConcurrentHashMap ............................................................... 330 10.5.2. Kolejki blokuj(cid:241)ce .............................................................................. 332 10.5.3. Inne struktury danych bezpieczne dla w(cid:241)tków ..................................... 333 10.6. Atomowe liczniki i akumulatory ........................................................................... 334 10.7. Blokady i warunki .............................................................................................. 336 10.7.1. Blokady ........................................................................................... 336 10.7.2. S(cid:228)owo kluczowe synchronized ............................................................ 337 10.7.3. Oczekiwanie warunkowe ................................................................... 339 10.8. W(cid:241)tki ............................................................................................................... 341 10.8.1. Uruchamianie w(cid:241)tku ......................................................................... 341 10.8.2. Przerywanie w(cid:241)tków ......................................................................... 342 Poleć książkęKup książkę 12 Java 9. Przewodnik do(cid:202)wiadczonego programisty 10.8.3. Zmienne lokalne w w(cid:241)tku ................................................................. 343 10.8.4. Dodatkowe w(cid:228)a(cid:264)ciwo(cid:264)ci w(cid:241)tku .......................................................... 344 10.9. Procesy ............................................................................................................ 345 10.9.1. Tworzenie procesu ........................................................................... 345 10.9.2. Uruchamianie procesu ...................................................................... 346 10.9.3. Uchwyty procesów ............................................................................ 347 (cid:231)wiczenia .................................................................................................................. 348 Rozdzia(cid:196) 11. Adnotacje ...........................................................................................................................353 11.1. U(cid:276)ywanie adnotacji ............................................................................................ 354 11.1.1. Elementy adnotacji ........................................................................... 355 11.1.2. Wielokrotne i powtarzane adnotacje ................................................... 356 11.1.3. Adnotacje deklaracji ......................................................................... 356 11.1.4. Adnotacje wykorzystania typów .......................................................... 357 11.1.5. Jawne okre(cid:264)lanie odbiorców .............................................................. 358 11.2. Definiowanie adnotacji ....................................................................................... 359 11.3. Adnotacje standardowe ..................................................................................... 361 11.3.1. Adnotacje do kompilacji .................................................................... 362 11.3.2. Adnotacje do zarz(cid:241)dzania zasobami ................................................... 363 11.3.3. Metaadnotacje ................................................................................. 364 11.4. Przetwarzanie adnotacji w kodzie ........................................................................ 365 11.5. Przetwarzanie adnotacji w kodzie (cid:274)ród(cid:228)owym ........................................................ 368 11.5.1. Przetwarzanie adnotacji .................................................................... 368 11.5.2. API modelu j(cid:246)zyka ............................................................................ 369 11.5.3. Wykorzystanie adnotacji do generowania kodu (cid:274)ród(cid:228)owego .................. 369 (cid:231)wiczenia .................................................................................................................. 372 Rozdzia(cid:196) 12. API daty i czasu .................................................................................................................373 12.1. Linia czasu ....................................................................................................... 374 12.2. Daty lokalne ..................................................................................................... 376 12.3. Modyfikatory daty .............................................................................................. 378 12.4. Czas lokalny ..................................................................................................... 379 12.5. Czas strefowy ................................................................................................... 380 12.6. Formatowanie i przetwarzanie ............................................................................. 383 12.7. Wspó(cid:228)praca z przestarza(cid:228)ym kodem .................................................................... 386 (cid:231)wiczenia .................................................................................................................. 387 Rozdzia(cid:196) 13. Internacjonalizacja ...........................................................................................................389 13.1. Lokalizacje ........................................................................................................ 390 13.1.1. Okre(cid:264)lanie lokalizacji ........................................................................ 391 13.1.2. Domy(cid:264)lna lokalizacja ........................................................................ 393 13.1.3. Nazwy wy(cid:264)wietlane ........................................................................... 394 13.2. Formaty liczb ..................................................................................................... 395 13.3. Waluty .............................................................................................................. 395 13.4. Formatowanie czasu i daty ................................................................................. 396 13.5. Porównywanie i normalizacja .............................................................................. 398 13.6. Formatowanie komunikatów ............................................................................... 400 13.7. Pakiety z zasobami ............................................................................................ 401 13.7.1. Organizacja pakietów z zasobami ...................................................... 402 13.7.2. Klasy z pakietami ............................................................................. 403 Poleć książkęKup książkę Spis tre(cid:202)ci 13 13.8. Kodowanie znaków ............................................................................................ 404 13.9. Preferencje ....................................................................................................... 405 (cid:231)wiczenia .................................................................................................................. 407 Rozdzia(cid:196) 14. Kompilacja i skryptowanie ...............................................................................................409 14.1. API kompilatora ................................................................................................. 410 14.1.1. Wywo(cid:228)anie kompilatora ..................................................................... 410 14.1.2. Uruchamianie zadania kompilacji ....................................................... 410 14.1.3. Wczytywanie plików (cid:274)ród(cid:228)owych z pami(cid:246)ci ........................................... 411 14.1.4. Zapisywanie skompilowanego kodu w pami(cid:246)ci .................................... 411 14.1.5. Przechwytywanie komunikatów diagnostycznych .................................. 413 14.2. API skryptów ..................................................................................................... 413 14.2.1. Tworzenie silnika skryptowego .......................................................... 413 14.2.2. Powi(cid:241)zania ...................................................................................... 414 14.2.3. Przekierowanie wej(cid:264)cia i wyj(cid:264)cia ........................................................ 415 14.2.4. Wywo(cid:228)ywanie funkcji i metod skryptowych .......................................... 415 14.2.5. Kompilowanie skryptu ...................................................................... 417 14.3. Silnik skryptowy Nashorn ................................................................................... 417 14.3.1. Uruchamianie Nashorna z wiersza polece(cid:254) ......................................... 417 14.3.2. Wywo(cid:228)ywanie metod pobieraj(cid:241)cych i ustawiaj(cid:241)cych dane oraz metod prze(cid:228)adowanych .............................................................. 418 14.3.3. Tworzenie obiektów j(cid:246)zyka Java ......................................................... 419 14.3.4. Ci(cid:241)gi znaków w j(cid:246)zykach JavaScript i Java .......................................... 420 14.3.5. Liczby .............................................................................................. 421 14.3.6. Praca z tablicami ............................................................................. 421 14.3.7. Listy i mapy ..................................................................................... 422 14.3.8. Wyra(cid:276)enia lambda ............................................................................ 423 14.3.9. Rozszerzanie klas Java i implementowanie interfejsów Java ................ 423 14.3.10. Wyj(cid:241)tki ............................................................................................ 425 14.4. Skrypty pow(cid:228)oki z silnikiem Nashorn .................................................................... 425 14.4.1. Wykonywanie polece(cid:254) pow(cid:228)oki ........................................................... 426 14.4.2. Uzupe(cid:228)nianie ci(cid:241)gów znaków ............................................................. 426 14.4.3. Wprowadzanie danych do skryptu ...................................................... 427 (cid:231)wiczenia .................................................................................................................. 428 Rozdzia(cid:196) 15. System modu(cid:196)ów na platformie Java ...............................................................................431 15.1. Koncepcja modu(cid:228)u ............................................................................................. 432 15.2. Nazywanie modu(cid:228)ów .......................................................................................... 434 15.3. Modularny program „Witaj, (cid:264)wiecie!” ................................................................... 435 15.4. Do(cid:228)(cid:241)czanie modu(cid:228)ów .......................................................................................... 436 15.5. Eksportowanie pakietów .................................................................................... 438 15.6. Modu(cid:228)y i dost(cid:246)p przez refleksje .......................................................................... 440 15.7. Modularne pliki JAR ........................................................................................... 442 15.8. Modu(cid:228)y automatyczne i modu(cid:228) unnamed .............................................................. 444 15.9. Flagi wiersza polece(cid:254) dla migracji ....................................................................... 446 15.10. Wymagania przechodnie i statyczne .................................................................. 447 15.11. Wybiórcze eksportowanie i otwieranie ............................................................... 449 15.12. Wczytywanie us(cid:228)ugi .......................................................................................... 450 15.13. Narz(cid:246)dzia do pracy z modu(cid:228)ami ........................................................................ 451 (cid:231)wiczenia .................................................................................................................. 453 Skorowidz .............................................................................................................................................455 Poleć książkęKup książkę 14 Java 9. Przewodnik do(cid:202)wiadczonego programisty Poleć książkęKup książkę 10 Programowanie wspó(cid:196)bie(cid:209)ne W tym rozdziale (cid:81) 10.1. Zadania wspó(cid:225)bie(cid:298)ne (cid:81) 10.2. Obliczenia asynchroniczne (cid:81) 10.3. Bezpiecze(cid:276)stwo w(cid:261)tków (cid:81) 10.4. Algorytmy równoleg(cid:225)e (cid:81) 10.5. Struktury danych bezpieczne dla w(cid:261)tków (cid:81) 10.6. Atomowe liczniki i akumulatory (cid:81) 10.7. Blokady i warunki (cid:81) 10.8. W(cid:261)tki (cid:81) 10.9. Procesy (cid:81) (cid:251)wiczenia J(cid:266)zyk Java by(cid:225) pierwszym z popularnych j(cid:266)zyków programowania z wbudowanym wsparciem programowania wspó(cid:225)bie(cid:298)nego. Pierwsi programi(cid:286)ci korzystaj(cid:261)cy z Javy entuzjastycznie przyj(cid:266)li prostot(cid:266), z jak(cid:261) mo(cid:298)na by(cid:225)o wczytywa(cid:252) pliki w drugoplanowych w(cid:261)tkach lub im- plementowa(cid:252) serwer internetowy obs(cid:225)uguj(cid:261)cy równolegle wiele (cid:298)(cid:261)da(cid:276). W tamtym czasie skupiano si(cid:266) na obci(cid:261)(cid:298)aniu procesora prac(cid:261) w czasie, gdy niektóre zadania czeka(cid:225)y na dane z sieci. Obecnie wi(cid:266)kszo(cid:286)(cid:252) komputerów posiada wiele procesorów lub rdzeni i programistom zale(cid:298)y na tym, by wykorzysta(cid:252) wszystkie procesory. W tym rozdziale nauczysz si(cid:266), jak dzieli(cid:252) obliczenia na wspó(cid:225)bie(cid:298)ne zadania i w jaki sposób bezpiecznie je wykonywa(cid:252). Skupi(cid:266) si(cid:266) na potrzebach programistów aplikacji, a nie systemo- wych pisz(cid:261)cych serwery internetowe lub oprogramowanie serwerowe. Z tego powodu informacje w tym rozdziale rozplanowa(cid:225)em w taki sposób, by tam, gdzie to mo(cid:298)liwe, najpierw pokaza(cid:252) narz(cid:266)dzia, których powiniene(cid:286) u(cid:298)ywa(cid:252) w swojej pracy. Konstrukcje niskopoziomowe opisz(cid:266) w dalszej cz(cid:266)(cid:286)ci tego rozdzia(cid:225)u. Znajomo(cid:286)(cid:252) tych niskopoziomowych szczegó(cid:225)ów przydaje si(cid:266) do tego, by mie(cid:252) wyczucie, z jakim kosztem wi(cid:261)(cid:298)e si(cid:266) wykonywanie Poleć książkęKup książkę 312 Java 9. Przewodnik do(cid:202)wiadczonego programisty poszczególnych operacji. Najlepiej jednak pozostawi(cid:252) niskopoziomowe programowanie w(cid:261)tków ekspertom. Je(cid:286)li zechcesz sta(cid:252) si(cid:266) jednym z nich, polecam wspania(cid:225)(cid:261) ksi(cid:261)(cid:298)k(cid:266) Java Concurrency in Practice (Brian Goetz i inni, Addison-Wesley, 2006). Najwa(cid:298)niejsze punkty tego rozdzia(cid:225)u: 1. Runnable opisuje zadanie, które mo(cid:298)e by(cid:252) wykonane asynchronicznie, ale nie zwraca wyniku. 2. ExecutorService planuje wykonanie instancji zada(cid:276). 3. Callable opisuje zadanie, które mo(cid:298)e by(cid:252) wykonane asynchronicznie i zwraca wynik. 4. Mo(cid:298)esz wys(cid:225)a(cid:252) jedn(cid:261) lub wi(cid:266)cej instancji Callable do ExecutorService i po(cid:225)(cid:261)czy(cid:252) wyniki, gdy b(cid:266)d(cid:261) dost(cid:266)pne. 5. Gdy wiele w(cid:261)tków pracuje na wspólnych danych bez synchronizacji, wyniki s(cid:261) nieprzewidywalne. 6. Lepiej u(cid:298)ywa(cid:252) algorytmów równoleg(cid:225)ych i bezpiecznych struktur danych, ni(cid:298) korzysta(cid:252) z blokad. 7. Równoleg(cid:225)e operacje na strumieniach i tablicach automatycznie i bezpiecznie zrównoleglaj(cid:261) wykonywanie operacji. 8. ConcurrentHashMap to bezpieczna dla w(cid:261)tków tablica skrótów pozwalaj(cid:261)ca aktualizowa(cid:252) elementy za pomoc(cid:261) operacji atomowych. 9. Mo(cid:298)esz u(cid:298)y(cid:252) klasy AtomicLong jako wspó(cid:225)dzielonego licznika bez konieczno(cid:286)ci tworzenia blokad lub wykorzysta(cid:252) LongAdder w przypadku du(cid:298)ej rywalizacji. 10. Blokada zapewnia, (cid:298)e tylko jeden w(cid:261)tek w danej chwili wykonuje krytyczny fragment kodu. 11. Zadanie, które mo(cid:298)na przerwa(cid:252), powinno ko(cid:276)czy(cid:252) dzia(cid:225)anie, gdy ustawiana jest flaga interrupted lub pojawia si(cid:266) wyj(cid:261)tek InterruptedException. 12. D(cid:225)ugie zadanie nie powinno blokowa(cid:252) interfejsu u(cid:298)ytkownika w programie, ale post(cid:266)p i ko(cid:276)cowa aktualizacja musz(cid:261) by(cid:252) wykonywane w w(cid:261)tku obs(cid:225)uguj(cid:261)cym interfejs u(cid:298)ytkownika. 13. Klasa Process pozwala wykonywa(cid:252) polecenia w oddzielnych procesach oraz wchodzi(cid:252) w interakcj(cid:266) ze strumieniem wej(cid:286)ciowym, wyj(cid:286)ciowym i b(cid:225)(cid:266)dów. 10.1. Zadania wspó(cid:196)bie(cid:209)ne Projektuj(cid:261)c program wspó(cid:225)bie(cid:298)ny, musisz my(cid:286)le(cid:252) na temat zada(cid:276), które mog(cid:261) by(cid:252) uruchamiane jednocze(cid:286)nie. W kolejnych punktach zobaczysz, jak wykonywa(cid:252) zadania równolegle. Poleć książkęKup książkę Rozdzia(cid:196) 10. (cid:81) Programowanie wspó(cid:196)bie(cid:209)ne 313 10.1.1. Uruchamianie zada(cid:198) W j(cid:266)zyku Java interfejs Runnable opisuje zadanie, które chcesz uruchomi(cid:252), by(cid:252) mo(cid:298)e równo- legle z innymi. public interface Runnable { void run(); } Tak jak w przypadku wszystkich metod, kod metody run jest wykonywany w w(cid:261)tku. W(cid:261)tek jest mechanizmem pozwalaj(cid:261)cym na wykonanie ci(cid:261)gu instrukcji, zazwyczaj dostarczanym przez system operacyjny. Wiele w(cid:261)tków dzia(cid:225)a równolegle, korzystaj(cid:261)c z ró(cid:298)nych procesorów lub ró(cid:298)nych odcinków czasu na tym samym procesorze. Je(cid:286)li chcesz wykona(cid:252) Runnable w oddzielnym w(cid:261)tku, móg(cid:225)by(cid:286) tworzy(cid:252) w(cid:261)tek dla ka(cid:298)dego Runnable — zobaczysz, jak to zrobi(cid:252) w punkcie 10.8.1, „Uruchamianie w(cid:261)tku”. W praktyce jednak zazwyczaj nie ma sensu utrzymywanie relacji „jeden do jednego” pomi(cid:266)dzy zadaniami i w(cid:261)tkami. Gdy zadania s(cid:261) krótkie, lepiej uruchomi(cid:252) wiele zada(cid:276) w tym samym w(cid:261)tku, by nie marnowa(cid:252) czasu na tworzenie w(cid:261)tku. Gdy Twoje zadania wymagaj(cid:261) wielu oblicze(cid:276), aby zminimalizowa(cid:252) narzut powstaj(cid:261)cy przy prze(cid:225)(cid:261)czaniu mi(cid:266)dzy w(cid:261)tkami, lepiej jest utworzy(cid:252) po jednym w(cid:261)tku na procesor, zamiast tworzy(cid:252) w(cid:261)tek dla ka(cid:298)dego zadania. Nie warto zawraca(cid:252) sobie tym g(cid:225)owy przy tworzeniu zada(cid:276), dlatego najlepiej oddzieli(cid:252) tworzenie zada(cid:276) i plano- wanie ich wykonania. W bibliotece Java wspieraj(cid:261)cej wspó(cid:225)bie(cid:298)no(cid:286)(cid:252) ExecutorService planuje wykonanie i wykonuje zadanie, wybieraj(cid:261)c w(cid:261)tki, w których ma by(cid:252) ono uruchomione. Runnable task = () - { ... }; ExecutorService executor = ...; executor.execute(task); Klasa Executors ma metody wytwórcze dla ró(cid:298)nych us(cid:225)ug wykonawców z ró(cid:298)nymi regu(cid:225)ami planowania. Wywo(cid:225)anie exec = Executors.newCachedThreadPool(); zwraca us(cid:225)ug(cid:266) z wykonawc(cid:261) zoptymalizowanym dla programów z wieloma krótkimi zada- niami lub sp(cid:266)dzaj(cid:261)cymi wi(cid:266)kszo(cid:286)(cid:252) czasu na oczekiwaniu. Ka(cid:298)de zadanie jest wykonywane w bezczynnym w(cid:261)tku, je(cid:286)li to mo(cid:298)liwe, ale gdy wszystkie w(cid:261)tki s(cid:261) zaj(cid:266)te, tworzony jest nowy w(cid:261)tek. Liczba równoleg(cid:225)ych w(cid:261)tków nie jest ograniczona. W(cid:261)tki bezczynne przez d(cid:225)u(cid:298)szy czas s(cid:261) likwidowane. Wywo(cid:225)anie exec = Executors.newFixedThreadPool(liczbaw(cid:230)tków); zwraca pul(cid:266) z okre(cid:286)lon(cid:261) liczb(cid:261) w(cid:261)tków. Gdy wysy(cid:225)asz zadanie, czeka ono w kolejce do czasu, gdy pojawi si(cid:266) dost(cid:266)pny w(cid:261)tek. Jest to dobre rozwi(cid:261)zanie w przypadku zada(cid:276) wymagaj(cid:261)cych wielu oblicze(cid:276) lub dla ograniczenia zasobów wykorzystywanych przez us(cid:225)ug(cid:266). Mo(cid:298)esz ustali(cid:252) liczb(cid:266) w(cid:261)tków na podstawie liczby dost(cid:266)pnych procesorów, któr(cid:261) otrzymujesz, pisz(cid:261)c int processors = Runtime.getRuntime().availableProcessors(); Poleć książkęKup książkę 314 Java 9. Przewodnik do(cid:202)wiadczonego programisty Teraz pora uruchomi(cid:252) program demonstruj(cid:261)cy wspó(cid:225)bie(cid:298)no(cid:286)(cid:252) z kodów do(cid:225)(cid:261)czonych do ksi(cid:261)(cid:298)ki. Wykonuje on równolegle dwa zadania. public static void main(String[] args) { Runnable powitania = () - { for (int i = 1; i = 1000; i++) System.out.println( Witaj + i); }; Runnable po(cid:318)egnania = () - { for (int i = 1; i = 1000; i++) System.out.println( (cid:317)egnaj + i); }; ExecutorService executor = Executors.newCachedThreadPool(); executor.execute(powitania); executor.execute(po(cid:318)egnania); } Uruchom program kilka razy, by zobaczy(cid:252), w jaki sposób przeplataj(cid:261) si(cid:266) wy(cid:286)wietlane liczby. (cid:317)egnaj 1 ... (cid:317)egnaj 871 (cid:317)egnaj 872 Witaj 806 (cid:317)egnaj 873 (cid:317)egnaj 874 (cid:317)egnaj 875 (cid:317)egnaj 876 (cid:317)egnaj 877 (cid:317)egnaj 878 (cid:317)egnaj 879 (cid:317)egnaj 880 (cid:317)egnaj 881 Witaj 807 (cid:317)egnaj 882 ... Witaj 1000 Mo(cid:276)esz zauwa(cid:276)y(cid:232), (cid:276)e program czeka chwil(cid:246) po wy(cid:264)wietleniu ostatniej linii. Ko(cid:254)czy dzia(cid:228)anie dopiero, gdy w(cid:241)tki z puli s(cid:241) przez jaki(cid:264) czas bezczynne i Executor ko(cid:254)czy ich dzia(cid:228)anie. Je(cid:264)li równolegle wykonywane zadania próbuj(cid:241) odczytywa(cid:232) lub aktualizowa(cid:232) wspó(cid:228)dzielon(cid:241) warto(cid:264)(cid:232), wynik mo(cid:276)e by(cid:232) nieprzewidywalny. Szczegó(cid:228)owo omówimy ten problem w podrozdziale 10.3., „Bezpiecze(cid:254)stwo w(cid:241)tków”. Na razie przyjmijmy, (cid:276)e zadania nie b(cid:246)d(cid:241) wspó(cid:228)dzieli(cid:228)y modyfikowalnych danych. 10.1.2. Obiekty Future Interfejs Runnable wykonuje zadanie, ale nie zwraca warto(cid:286)ci. Je(cid:286)li masz zadanie obliczaj(cid:261)ce wynik, zamiast Runnable u(cid:298)yj interfejsu Callable V . Jego metoda call, w przeciwie(cid:276)stwie do metody run interfejsu Runnable, zwraca warto(cid:286)(cid:252): Poleć książkęKup książkę Rozdzia(cid:196) 10. (cid:81) Programowanie wspó(cid:196)bie(cid:209)ne 315 public interface Callable V { V call() throws Exception; } Dodatkowo metoda call mo(cid:298)e wyrzuci(cid:252) dowolne wyj(cid:261)tki, które mog(cid:261) zosta(cid:252) przekazane do kodu otrzymuj(cid:261)cego wyniki. Aby wykona(cid:252) Callable, prze(cid:286)lij go do us(cid:225)ugi wykonawcy: ExecutorService executor = Executors.newFixedThreadPool(); Callable V zadanie = ...; Future V wynik = executor.submit(zadanie); Wysy(cid:225)aj(cid:261)c zadanie, otrzymujesz obiekt Future reprezentuj(cid:261)cy obliczenia, których wynik b(cid:266)dzie dost(cid:266)pny w przysz(cid:225)o(cid:286)ci. Interfejs Future ma nast(cid:266)puj(cid:261)ce metody: V get() throws InterruptedException, ExecutionException V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; boolean cancel(boolean mayInterruptIfRunning) boolean isCancelled() boolean isDone() Metoda get jest zablokowana, dopóki nie pojawi si(cid:266) wynik lub nie zostanie przekroczony czas wykonania. Oznacza to, (cid:298)e w(cid:261)tek zawieraj(cid:261)cy jej wywo(cid:225)anie nie posuwa si(cid:266) do przodu, dopóki metoda nie zako(cid:276)czy si(cid:266) lub nie wyrzuci wyj(cid:261)tku. Je(cid:286)li metoda call wyrzuci(cid:225)a wyj(cid:261)tek, metoda get wyrzuca wyj(cid:261)tek ExecutionException opakowuj(cid:261)cy wyrzucony wyj(cid:261)tek. Je(cid:286)li zostanie przekroczony czas wykonania, metoda get wyrzuca wyj(cid:261)
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java 9. Przewodnik doświadczonego programisty. Wydanie II
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: