Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00456 007989 10478191 na godz. na dobę w sumie
Java. Ćwiczenia zaawansowane - książka
Java. Ćwiczenia zaawansowane - książka
Autor: Liczba stron: 144
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-947-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).
Ćwiczenia zaawansowane są kolejnym etapem na drodze doskonalenia informatycznych umiejętności. Czytelnicy, którzy poznali poprzednią książką Marcina Lisa 'Java. Ćwiczenia praktyczne', z całą pewnością nie będą zawiedzeni.

Z niniejszej publikacji dowiemy się, jak pisać programy wielowątkowe i jak w Javie obsługiwać bazy danych. Napiszemy własny, gotowy do praktycznego użycia czat oraz aplikację do wysyłania SMS-ów. Nauczymy się też tworzyć aplikacje sieciowe z interfejsem graficznym!

Wybrane zagadnienia:

Książka otwiera nową serię wydawniczą, której głównym zadaniem będzie poszerzenie uzyskanych wiadomości.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TRE(cid:140)CI SPIS TRE(cid:140)CI KATALOG KSI¥flEK KATALOG KSI¥flEK KATALOG ONLINE KATALOG ONLINE ZAM(cid:211)W DRUKOWANY KATALOG ZAM(cid:211)W DRUKOWANY KATALOG TW(cid:211)J KOSZYK TW(cid:211)J KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAM(cid:211)W INFORMACJE ZAM(cid:211)W INFORMACJE O NOWO(cid:140)CIACH O NOWO(cid:140)CIACH ZAM(cid:211)W CENNIK ZAM(cid:211)W CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥flEK ONLINE FRAGMENTY KSI¥flEK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Java. ˘wiczenia zaawansowane Autor: Marcin Lis ISBN: 83-7197-947-9 Format: B5, stron: 142 ˘wiczenia zaawansowane s„ kolejnym etapem na drodze doskonalenia informatycznych umiejŒtno(cid:156)ci. Czytelnicy, kt(cid:243)rzy poznali poprzedni„ ksi„¿k„ Marcina Lisa (cid:132)Java. ˘wiczenia praktyczne(cid:148), z ca‡„ pewno(cid:156)ci„ nie bŒd„ zawiedzeni. Z niniejszej publikacji dowiemy siŒ, jak pisa(cid:230) programy wielow„tkowe i jak w Javie obs‡ugiwa(cid:230) bazy danych. Napiszemy w‡asny, gotowy do praktycznego u¿ycia czat oraz aplikacjŒ do wysy‡ania SMS-(cid:243)w. Nauczymy siŒ te¿ tworzy(cid:230) aplikacje sieciowe z(cid:160) interfejsem graficznym! Wybrane zagadnienia: W„tki i programowanie wsp(cid:243)‡bie¿ne w Javie Synchronizacja w„tk(cid:243)w Programowanie sieciowe Czym s„ gniazda? Serwer wielow„tkowy £„czenie z baz„ danych Dodawanie rekord(cid:243)w Modyfikacja rekord(cid:243)w w bazie Obs‡uga transakcji i warto(cid:156)ci null Aplikacja z interfejsem graficznym Ksi„¿ka otwiera now„ seriŒ wydawnicz„, kt(cid:243)rej g‡(cid:243)wnym zadaniem bŒdzie poszerzenie uzyskanych wiadomo(cid:156)ci. Wstęp...................................................z...................................................z................................................ 5 Rozdział 1. Wątki i programowanie współbieżne w Javie ...................................................z................. 7 Klasa Thread ...................................................d...................................................d........... 7 Interfejs Runnable...................................................d...................................................d. 11 Synchronizacja wątków ...................................................d........................................... 17 Rozdział 2. Programowanie sieciowe...................................................z.......................................................29 Czym są gniazda? ...................................................d...................................................d. 29 Gniazda w Javie ...................................................d...................................................d.... 30 Klient i serwer...................................................d...................................................d....... 35 Transmisja danych ...................................................d...................................................d 39 Serwer wielowątkowy ...................................................d............................................. 49 Rozdział 3. Aplikacje sieciowe z interfejsem graficznym ...................................................z............. 63 Prawdziwa aplikacja — czat (chat) w Javie...................................................d.............. 63 Chat Serwer ...................................................d...................................................d.......... 77 Wyślij SMS...................................................d...................................................d........... 88 Idea...................................................d...................................................d................. 92 Rozdział 4. Bazy danych...................................................z...................................................z................................. 97 Łączenie z bazą danych ...................................................d........................................... 97 Dodawanie rekordów...................................................d............................................. 106 Modyfikacja rekordów w bazie ...................................................d............................. 112 Obsługa transakcji i wartości null ...................................................d......................... 120 Aplikacja z interfejsem graficznym...................................................d....................... 126 Wątki w Javie reprezentowane są przez klasę $6/+., znajdującą się w pakiecie +:+ +21. Program korzystający z więcej niż jednego wątku możemy utworzyć na dwa sposoby. Albo wyprowadzimy własną, nową klasę z klasy $6/+., albo też nasza klasa będzie musiała implementować interfejs 922+,/. Zajmijmy się na początku metodą pierwszą. Utworzymy dwie klasy: klasę główną np. +2 i klasę rozszerzającą klasę $6/+. np. $6/+.. W klasie $6/+. należy zdefiniować metodę 692(cid:19)(cid:20), od której rozpocznie się działanie wątku; w klasie +2 trzeba utworzyć obiekt klasy $6/+. i wywołać jego metodę 78+68(cid:19)(cid:20). Najlepiej wykonać od razu odpowiedni przykład. Ćwiczenie 1.1. Napisz kod klasy $6/+. dziedziczącej z klasy $6/+.. 49,- -+77$6/+./8/2.7$6/+.  49,-$6/+.(cid:21)(cid:22)  794/6(cid:21)(cid:22)  49,-:3.692(cid:21)(cid:22)  #78/ 398 46282(cid:21)$6/+.$6/+.(cid:22)   8 Ćwiczenie 1.2. Java. Ćwiczenia zaawansowane Napisz kod klasy +2 tworzący wątek $6/+.. 49,--+77+2  49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  $6/+.$6/+.2/;$6/+.(cid:21)(cid:22) $6/+. 78+68(cid:21)(cid:22) #78/ 398 46282(cid:21)$6/+.+2(cid:22)   Jeśli spojrzymy teraz na rysunek 1.1, przekonamy się, że oba wątki faktycznie zostały wykonane. Podobny efekt możemy osiągnąć również w nieco inny sposób. Nie trzeba tworzyć oddzielnie klasy uruchomieniowej dla wątku (w naszym przypadku była to klasa +2). Wystarczy w klasie wyprowadzonej z $6/+. zdefiniować metodę +2 i tam utworzyć obiekty wątków. Rysunek 1.1. Wyraźnie widać, że oba wątki zostały wykonane Ćwiczenie 1.3. Napisz kod klasy $6/+. wyprowadzonej z klasy $6/+., uruchamiającej dwa przykła- dowe wątki. 49,- -+77$6/+./8/2.7$6/+.  49,-$6/+.(cid:21)(cid:22)  794/6(cid:21)(cid:22)  49,-:3.692(cid:21)(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)(cid:22)  49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;$6/+.(cid:21)(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21)(cid:22) 78+68(cid:21)(cid:22)   Rozdział 1. L Wątki i programowanie współbieżne w Javie 9 Efekt działania kodu z ćwiczenia 1.3 widoczny jest na rysunku 1.2. Na ekranie wyświe- tlone są nazwy wątków nadane im przez system. Wykorzystaliśmy w tym celu metodę 1/8+/(cid:19)(cid:20) klasy $6/+.. Warto zauważyć, że w tej chwili mamy inną sytuację niż w po- przednich przykładach. W ćwiczeniach 1.1 i 1.2 występowały dwa wątki, wątek główny i wątek klasy $6/+.. Teraz mamy trzy wątki — wątek główny, którego wykonanie rozpoczyna się od metody +2(cid:19)(cid:20), oraz dwa wątki tworzone przez nas w tej metodzie, których wykonywanie rozpoczyna się od metody 692(cid:19)(cid:20). Rysunek 1.2. Na ekranie wyświetlone zostały systemowe nazwy wątków Gdybyśmy chcieli samodzielnie nadać nazwy poszczególnym wątkom, możemy nazwy te przekazać jako parametr w konstruktorze klasy $6/+., a następnie skorzystać z metody 7/8+/(cid:19)(cid:20). Ćwiczenie 1.4. Zmodyfikuj kod z ćwiczenia 1.3 w taki sposób, aby istniała możliwość nadania własnych nazw wątkom. 49,- -+77$6/+./8/2.7$6/+.  49,-$6/+.(cid:21)#86212+/(cid:22)  794/6(cid:21)(cid:22) 7/8+/(cid:21)2+/(cid:22)  49,-:3.692(cid:21)(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)(cid:22)  49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;$6/+.(cid:21) 8/) (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21) 8/)(cid:22) 78+68(cid:21)(cid:22)   Spróbujmy jednak przekonać się, że rzeczywiście nasze wątki wykonują się niezależnie od siebie. Wystarczy, jeśli dopiszemy pętlę wyświetlającą kilkukrotnie nazwę każdego wątku. 10 Ćwiczenie 1.5. Java. Ćwiczenia zaawansowane Napisz przykładowy kod ilustrujący niezależne działanvie wątków. 49,- -+77$6/+./8/2.7$6/+.  28./+ 49,-$6/+.(cid:21)#86212+/,28./+(cid:22)  794/6(cid:21)(cid:22) 7/8+/(cid:21)2+/(cid:22) 87 ./+./+  49,-:3.692(cid:21)(cid:22)  036(cid:21)28 11(cid:22) #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)    49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;$6/+.(cid:21) /6;7,(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21)691, (cid:22) 78+68(cid:21)(cid:22)   Dodatkowo „wyposażyliśmy” nasze wątki w metodę 7//4(cid:19)(cid:20), która „usypia” je na zadaną ilość milisekund. Dzięki temu możemy spowodować, że każdy z nich wypisuje dane na ekran z inną prędkością. Efekt różnych prędkości działania widać wyraźnie na rysunku 1.3. Rysunek 1.3. Widać wyraźnie, że wątki wykonują się niezależnie od siebie Rozdział 1. L Wątki i programowanie współbieżne w Javie 11 Wyprowadzanie własnej klasy z klasy $6/+. jest wygodne, ale nie zawsze możliwe. Z sytuacją taką będziemy mieli do czynienia, gdy nasza klasa już dziedziczy z innej, a musimy uzupełnić ją o możliwość działania wielowątkowego. Na szczęście istnieje interfejs 922+,/, który pomoże nam w rozwiązaniu tego problemu. W interfejsie 922+,/ zdefiniowana jest jedna metoda: 692(cid:19)(cid:20), od której, podobnie jak w przypadku klasy $6/+., rozpoczyna się wykonywanie kodu wątku. W celu uruchomie- nia nowego wątku tworzymy nowy obiekt naszej klasy, a następnie używamy go jako parametru konstruktora klasy $6/+.. Schematycznie wygląda to następująco (zakładając, że +77 implementuje 922+,/): +77+77$6/+.2/;+77(cid:21)(cid:22) 2/;$6/+.(cid:21)+77$6/+.(cid:22) Dostępne konstruktory klasy $6/+. przedstawione są w tabeli 1.1. Tabela 1.1. Konstruktory klasy Thread Konstruktor $6/+.(cid:21)(cid:22) $6/+.(cid:21) 922+,/8+61/8(cid:22) Opis Konstruktor bezparametrowy. Tworzy nowy obiekt klasby $6/+. Tworzy nowy obiekt klasy $6/+. związany z obiektem docelowym 8+61/8 $6/+.(cid:21) 922+,/8+61/8, #86212+/(cid:22) Tworzy nowy obiekt klasy $6/+. związany z obiektem docelowym 8+61/8, o nazwie 2+/ $6/+.(cid:21)#86212+/(cid:22) Tworzy nowy obiekt klasy $6/+. o nazwie 2+/ $6/+.(cid:21)$6/+.639416394, 922+,/8+61/8(cid:22) Tworzy nowy obiekt klasy $6/+. związany z obiektem docelowym 8+61/8, przypisany do grupy 16394 $6/+.(cid:21)$6/+.639416394, 922+,/8+61/8,#86212+/(cid:22) Tworzy nowy obiekt klasy $6/+. o nazwie 2+/, związany z obiektem docelowym 8+61/8, przypisany do grupy 16394 $6/+.(cid:21)$6/+.639416394, #86212+/(cid:22) Tworzy nowy obiekt klasy $6/+. o nazwie 2+/, przypisany do grupy 16394 Ćwiczenie 1.6. Napisz przykładowy kod ilustrujący niezależne działanie wątków. Skorzystaj z interfejsu 922+,/. 49,- -+77+24//287 922+,/  28./+ #8621;36. 49,-+2(cid:21)#8621;36.,28./+(cid:22)  87 ./+./+ 87 ;36.;36.  12 Java. Ćwiczenia zaawansowane 49,-:3.692(cid:21)(cid:22)  036(cid:21)28 11(cid:22) #78/ 398 46282(cid:21);36.11(cid:22) 86 $6/+. 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)    49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  922+,/86/+. 2/;+2(cid:21)86/+. ,(cid:22) 922+,/86/+.2/;+2(cid:21)86/+., (cid:22) 2/;$6/+.(cid:21)86/+. (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21)86/+.(cid:22) 78+68(cid:21)(cid:22)   Dobrym przykładem wykorzystania interfejsu 922+,/ jest klasa posiadająca interfejs graficzny. Nie możemy w takim przypadku dziedziczyć bezpośrednio z klasy $6/+., gdyż np. utworzenie okna wymaga dziedziczenia z klasy 6+/, a wielodziedziczenia w Javie nie ma. Stosujemy więc interfejs 922+,/, który rozwiązuje nasz problem. Posta- rajmy się zatem napisać prostą aplikację z interfejsem graficznym, która będzie wyko- nywała przykładowe obliczenia w osobnym wątku. Ćwiczenie 1.7. Napisz aplikację z interfejsem graficznym, wykonującą w osobnym wątku przykładowe obliczenia. Stan obliczeń powinien być sygnalizowany uvżytkownikowi. 4368+:+ +;8  4368+:+ +;8 /:/28  49,- -+77+2/8/2.76+/4//287 922+,/,-83278/2/6, 2.3;78/2/6  46:+8/#8621;-$6/+. 4638/-8/.78+8-98832,#8+68 4638/-8/.78+8-98832,#834 4638/-8/.78+8-+,/ 6316/77 4638/-8/.78+8-,33/+278344/. 49,-+2(cid:21)#8621;-$6/+.(cid:22)  794/6(cid:21)(cid:22) 87 ;-$6/+.;-$6/+. 0(cid:21)+2 /59+7(cid:21);-$6/+.(cid:22)(cid:22) 6/8962  +.. 2.3;78/2/6(cid:21)87(cid:22) 7/8+398(cid:21)29(cid:22) 7/8#/(cid:21) , (cid:22) ,#8+682/;98832(cid:21)#8+68(cid:22) ,#8+68 7/8392.7(cid:21) ,  , , (cid:22) Rozdział 1. L Wątki i programowanie współbieżne w Javie 13 ,#8+68 +..-83278/2/6(cid:21)87(cid:22) +..(cid:21),#8+68(cid:22) ,#8342/;98832(cid:21)#834(cid:22) ,#834 7/8392.7(cid:21) ,  , , (cid:22) ,#834 +..-83278/2/6(cid:21)87(cid:22) +..(cid:21),#834(cid:22)  6316/772/;+,/(cid:21) (cid:22)  6316/77 7/8392.7(cid:21) , , , (cid:22) +..(cid:21) 6316/77(cid:22) ,#8+68 7/82+,/.(cid:21)869/(cid:22) ,#834 7/82+,/.(cid:21)0+7/(cid:22) 7/8 7,/(cid:21)869/(cid:22)  49,-:3.692(cid:21)(cid:22)  78344/.0+7/ 036(cid:21)28  11(cid:22) 86 $6/+. 7//4(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  0(cid:21)78344/.(cid:22) ,6/+   6316/77 7/8$/8(cid:21)28/1/6 83#8621(cid:21)1 (cid:22)1(cid:22)  ,#8+68 7/82+,/.(cid:21)869/(cid:22) ,#834 7/82+,/.(cid:21)0+7/(cid:22)  49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;+2(cid:21)+2(cid:22)  49,-:3.+-832 /6036/.(cid:21)-832:/28/:8(cid:22) #862184/:8 1/8-8323+2.(cid:21)(cid:22) 0(cid:21)84 /59+7(cid:21)#8+68(cid:22)(cid:22) ,#8+68 7/82+,/.(cid:21)0+7/(cid:22) +2+22/;+2(cid:21)-3498/(cid:22) 2/;$6/+.(cid:21)+2(cid:22) 78+68(cid:21)(cid:22) ,#834 7/82+,/.(cid:21)869/(cid:22)  /7/0(cid:21)84 /59+7(cid:21)#834(cid:22)(cid:22) 78344/.869/   49,-:3.;2.3;/-320/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;37/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;/+-8:+8/.(cid:21) 2.3;:/28/:8(cid:22)  14 Java. Ćwiczenia zaawansowane  49,-:3.;2.3;3721(cid:21) 2.3;:/28/:8(cid:22)  #78/ /8(cid:21) (cid:22)  49,-:3.;2.3;-8:+8/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;-320/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;4/2/.(cid:21) 2.3;:/28/:8(cid:22)    Rysunek 1.4. Po kliknięciu przycisku Start rozpoczęły się obliczenia W metodzie 692(cid:19)(cid:20) napisaliśmy zwykłą pętlę 036 symulującą wykonywanie jakichś obliczeń. Co 250 milisekund uaktualnia ona tekst etykiety  6316/77. Wykonywanie tej operacji rozpoczyna się po naciśnięciu przycisku Start. Działanie pętli możemy przerwać po- przez wciśnięcie przycisku Stop, następuje wtedy przypisanie zmiennej 78344/. wartości 869/. Wartość tej zmiennej sprawdzana jest cyklicznie, zatem po takim przypisaniu nastąpi przerwanie działania. Musimy tutaj zdawać sobie jednak sprawę, że mamy dwa obiekty klasy +2. Jeden z nich tworzony jest w metodzie +2(cid:19)(cid:20), drugi po naciśnięciu przycisku Start. Zatem jeśli mają one ze sobą współpracować na takiej zasadzie jak przedstawiona powyżej, zmienne ,#8+68, ,#834,  6316/77 i 78344/. muszą być zadeklarowane jako statyczne. Inaczej każdy wątek będzie operował na własnej, lokalnej kopii tych zmiennych i całość oczy- wiście nie będzie działać. Nic nie stoi jednak na przveszkodzie, aby aplikację tę skonstru- ować w taki sposób, aby wątek był tworzony znanym nam już sposobem, przez oddzielną klasę, pochodną od $6/+.. Ćwiczenie 1.8. Napisz kod klasy $6/+. symulującej wykonywanie obliczeń i współpracującej z klasą +2 realizującą interfejs graficzny. 49,- -+77$6/+./8/2.7$6/+.  28./+ +24+6/28 ,33/+278344/. 49,-$6/+.(cid:21)+24+6/28,28./+(cid:22) Rozdział 1. L Wątki i programowanie współbieżne w Javie 15  794/6(cid:21)(cid:22) 87 ./+./+ 87 4+6/284+6/28  49,-:3.692(cid:21)(cid:22)  78344/.0+7/ 036(cid:21)28  11(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  0(cid:21)78344/.(cid:22) ,6/+  4+6/28  6316/77 7/8$/8(cid:21)28/1/6 83#8621(cid:21)1 (cid:22)1(cid:22)    Metoda 692(cid:19)(cid:20) wygląda tu bardzo podobnie, jak w poprzednim ćwiczeniu. Różnice są takie, że opóźnienie jest teraz sparametryzowane, możemy je regulować wartością zmiennej ./+ (jest ona przekazywana w konstruktorze klasy) oraz że wprowadziliśmy zmienną 4+6/28, która jest referencją do obiektu klasy +2 i umożliwia nam komunikację z nim. Dzięki temu możemy modyfikować tekst pojawiający się na ekranie. Musimy w tej chwili tylko przystosować klasę +2 do współpracy z naszym nowym wątkiem. Ćwiczenie 1.9. Napisz kod klasy +2 wykorzystującej przygotowaną w ćwiczeniu 1.8 klasę vwątku. 4368+:+ +;8  4368+:+ +;8 /:/28  49,- -+77+2/8/2.76+/4//287-83278/2/6, 2.3;78/2/6  4638/-8/.98832,#8+68 4638/-8/.98832,#834 4638/-8/.+,/ 6316/77 4638/-8/.$6/+.86/+. 49,-+2(cid:21)(cid:22)  794/6(cid:21)(cid:22) +.. 2.3;78/2/6(cid:21)87(cid:22) 7/8+398(cid:21)29(cid:22) 7/8#/(cid:21) , (cid:22) ,#8+682/;98832(cid:21)#8+68(cid:22) ,#8+68 7/8392.7(cid:21) ,  , , (cid:22) ,#8+68 +..-83278/2/6(cid:21)87(cid:22) +..(cid:21),#8+68(cid:22) 16 Java. Ćwiczenia zaawansowane ,#8342/;98832(cid:21)#834(cid:22) ,#834 7/8392.7(cid:21) ,  , , (cid:22) ,#834 +..-83278/2/6(cid:21)87(cid:22) +..(cid:21),#834(cid:22)  6316/772/;+,/(cid:21) (cid:22)  6316/77 7/8392.7(cid:21) , , , (cid:22) +..(cid:21) 6316/77(cid:22) ,#8+68 7/82+,/.(cid:21)869/(cid:22) ,#834 7/82+,/.(cid:21)0+7/(cid:22) 7/8 7,/(cid:21)869/(cid:22)  49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;+2(cid:21)(cid:22)  49,-:3.+-832 /6036/.(cid:21)-832:/28/:8(cid:22) #862184/:8 1/8-8323+2.(cid:21)(cid:22) 0(cid:21)84 /59+7(cid:21)#8+68(cid:22)(cid:22) ,#8+68 7/82+,/.(cid:21)0+7/(cid:22) 86/+.2/;$6/+.(cid:21)87, (cid:22) 86/+. 78+68(cid:21)(cid:22) ,#834 7/82+,/.(cid:21)869/(cid:22)  /7/0(cid:21)84 /59+7(cid:21)#834(cid:22)(cid:22) 86/+. 78344/.869/ ,#8+68 7/82+,/.(cid:21)869/(cid:22) ,#834 7/82+,/.(cid:21)0+7/(cid:22)   49,-:3.;2.3;/-320/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;37/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;/+-8:+8/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;3721(cid:21) 2.3;:/28/:8(cid:22)  #78/ /8(cid:21) (cid:22)  49,-:3.;2.3;-8:+8/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;-320/.(cid:21) 2.3;:/28/:8(cid:22)   49,-:3.;2.3;4/2/.(cid:21) 2.3;:/28/:8(cid:22)    Rozdział 1. L Wątki i programowanie współbieżne w Javie 17 Rozważmy w tej chwili następującą sytuację: mamy zmienną typu całkowitego i dwa wątki modyfikujące jej wartość. Załóżmy, że będzie to dodawanie w pętli w każdym przebiegu wartości 1, a sama pętla będzie miała tych przebiegów 10. Jaka będzie ostateczna wartość naszej zmiennej? Jeśli pierwszy wątek 10 razy zwiększył wartość o 1 i drugi wątek zrobił to samo, to w sumie powinno dać 20. Napiszmy taki program. Ćwiczenie 1.10. Napisz program, w którym dwa wątki będą niezależnie od siebie modyfikowały wartość jednej zmiennej typu 28. 49,- -+77$6/+./8/2.7$6/+.  46:+8/28;-$6/+. 46:+8/28./+ 46:+8/78+8-28+--3928  49,-$6/+.(cid:21)28;-$6/+.,28./+(cid:22)  794/6(cid:21)(cid:22) 87 ./+./+ 87 ;-$6/+.;-$6/+.  49,-:3.692(cid:21)(cid:22)  7;8-(cid:21);-$6/+.(cid:22) -+7/ 86/+. (cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+   49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;$6/+.(cid:21) , (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21),(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21), (cid:22) 78+68(cid:21)(cid:22)  49,-:3.86/+. (cid:21)(cid:22)  036(cid:21)28  11(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--392811   49,-:3.86/+.(cid:21)(cid:22)  036(cid:21)28  11(cid:22) 86 7//4(cid:21)./+(cid:22) 18 Java. Ćwiczenia zaawansowane  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--392811   49,-72-632/.:3.86/+.(cid:21)(cid:22)  86 ;+8(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22) #78/ 398 46282(cid:21)/(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   Wątki 86/+. i 86/+. zajmują się zwiększaniem wartości zmiennej +--3928. Jedynym zadaniem wątku 86/+. jest odczekanie 1 000 milisekund i wyświetlenie wartości zmiennej +--3928. Uruchomienie powyższego kodu wykaże, że faktycznie otrzymamy wartość 20, tak jak przewidzieliśmy wcześniej. Czy zatem wszystko jest w porządku? Jak najbardziej. Co się jednak stanie, jeśli instrukcja modyfikująca +--3928 będzie w postaci +--3928 +--3928  ? Napiszmy taki program. Ćwiczenie 1.11. Zmodyfikuj kod z ćwiczenia 1.10 w taki sposób, aby modyfikacja zmiennej +--3928 była w postaci: +--3928+--3928  . 49,- -+77$6/+./8/2.7$6/+.  46:+8/28;-$6/+. 46:+8/28./+ 46:+8/78+8-28+--3928  49,-$6/+.(cid:21)28;-$6/+.,28./+(cid:22)  794/6(cid:21)(cid:22) 87 ./+./+ 87 ;-$6/+.;-$6/+.  49,-:3.692(cid:21)(cid:22)  7;8-(cid:21);-$6/+.(cid:22) -+7/ 86/+. (cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+   49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;$6/+.(cid:21) , (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21),(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21), (cid:22) 78+68(cid:21)(cid:22)  Rozdział 1. L Wątki i programowanie współbieżne w Javie 19 49,-:3.86/+. (cid:21)(cid:22)  036(cid:21)28  11(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--3928+--39281    49,-:3.86/+.(cid:21)(cid:22)  036(cid:21)28  11(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--3928+-3-9281    49,-72-632/.:3.86/+.(cid:21)(cid:22)  86 ;+8(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22) #78/ 398 46282(cid:21)/(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   Modyfikacje nie były duże, a po uruchomieniu ujrzymy prawdopodobnie również wynik 20. Czy zatem wszystko znowu jest w porządku? Otóż absolutnie nie! Wszystko zależy teraz od kompilatora. Jeśli jest on „inteligentny”, prawdopodobnie potraktuje instrukcję +--3928  +--3928  jako +--3928 . W takim wypadku faktycznie program będzie prawi- dłowy, gdyż +--3928 jest instrukcją atomową, tzn. nie może być ona przerwana przez inny wątek. Niestety nie należy przyjmować takiego założenia, natomiast trzeba traktować taki kod jako złożenie następujących operacji: L pobranie wartości +--3928, L dodanie do tej wartości 1, L zapisanie otrzymanej wartości do zmiennej +--3928. Skoro tak, operacje te mogą zostać przerwane przez inny wątek. Co się wtedy stanie? Otóż otrzymany wynik na pewno nie będzie prawidłowy. Żeby się o tym przekonać, zasymulu- jemy przerywanie tych operacji. Zrobimy to w sposób następujący: L wartość zmiennej +--3928 będziemy modyfikować w dwóch krokach, L pomiędzy poszczególnymi operacjami dodamy instrukcjvę 7//4(cid:19)(cid:20), usypiającą dany wątek. 20 Java. Ćwiczenia zaawansowane Kod w każdym wątku powinien zatem wyglądać następujvąco: 288/4 036(cid:21)28  11(cid:22) 8/4+--3928 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--39288/41  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)  Ćwiczenie 1.12. Napisz program wymuszający wzajemne przerywanie pracy wątków przy modyfikacji wspólnej zmiennej typu 28. 49,- -+77$6/+./8/2.7$6/+.  46:+8/28;-$6/+. 46:+8/28./+ 46:+8/78+8-28+--3928  49,-$6/+.(cid:21)28;-$6/+.,28./+(cid:22)  794/6(cid:21)(cid:22) 87 ./+./+ 87 ;-$6/+.;-$6/+.  49,-:3.692(cid:21)(cid:22)  7;8-(cid:21);-$6/+.(cid:22) -+7/ 86/+. (cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+   49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  2/;$6/+.(cid:21) , (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21),(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21), (cid:22) 78+68(cid:21)(cid:22)  49,-:3.86/+. (cid:21)(cid:22)  288/4 036(cid:21)28  11(cid:22) 8/4+--3928 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--39288/41  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)  Rozdział 1. L Wątki i programowanie współbieżne w Javie 21  49,-:3.86/+.(cid:21)(cid:22)  288/4 036(cid:21)28  11(cid:22) 8/4+--3928 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--39288/41  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   49,-72-632/.:3.86/+.(cid:21)(cid:22)  86 ;+8(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22) #78/ 398 46282(cid:21)/(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   Instrukcje #78/ 398 46282 dokładnie pokazują nam, co się dzieje. Wynik oczywiście nie jest prawidłowy, gdyż pomiędzy pobraniem wartości +--3928 a jej modyfikacją i ponownym zapisaniem w każdym wątku występuje przerwa, umożliwiająca wykonanie operacji przez inny wątek. Skutek jest taki, że — mówiąc potocznie — „nie wie lewica, co robi prawica” i wynik jest zafałszowany. Rysunek 1.5. Widać wyraźnie, że wątki sobie wzajemnie przeszkadzają Jest to typowy przykład dostępu do zasobu współdzielonego przez pracujące współ- bieżnie wątki. Aby zatem nasz przykład był poprawny, musimy dokonać ich synchroni- zacji. W Javie służy do tego instrukcja 72-632/.. Możemy ją stosować zarówno w przypadku metod (ang. synchronized methods), jak i obiektów. Jeżeli zadeklarujemy metodę jako 72-632/., np.: 22 Java. Ćwiczenia zaawansowane 49,-72-632/.:3.73;(cid:21)(cid:22)  27869-/  to wywołanie takiej metody powoduje zablokowanie obiektu, na rzecz którego jest ona wywoływana. Obiekt ten będzie zablokowany, aż do zakończenia wykonywania tejże instrukcji i inne wątki nie będą miały do niego dostępu. Druga metoda to zablokowanie obiektu w postaci: #2-632/.(cid:21)3,/8(cid:22)  27869-/  przy czym obiekt użyty do synchronizacji nie musi być użyty w bloku instrukcji. Spró- bujmy zatem zsynchronizować dostęp do zmiennej +--3928 z poprzedniego ćwiczenia. Ćwiczenie 1.13. Dokonaj synchronizacji dostępu do zmiennej +--3928 z ćwiczenia 1.12. 49,- -+77$6/+./8/2.7$6/+.  46:+8/28;-$6/+. 46:+8/28./+ 46:+8/78+8-28+--3928  46:+8/78+8-,/-87/+436/ 49,-$6/+.(cid:21)28;-$6/+.,28./+(cid:22)  794/6(cid:21)(cid:22) 87 ./+./+ 87 ;-$6/+.;-$6/+.  49,-:3.692(cid:21)(cid:22)  7;8-(cid:21);-$6/+.(cid:22) -+7/ 86/+. (cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+   49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  7/+436/2/;,/-8(cid:21)(cid:22) 2/;$6/+.(cid:21) , (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21),(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21), (cid:22) 78+68(cid:21)(cid:22)  49,-:3.86/+. (cid:21)(cid:22)  288/4 036(cid:21)28  11(cid:22) 72-632/.(cid:21)7/+436/(cid:22) 8/4+--3928 Rozdział 1. L Wątki i programowanie współbieżne w Javie 23 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--39288/41   #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   49,-:3.86/+.(cid:21)(cid:22)  288/4 036(cid:21)28  11(cid:22) 72-632/.(cid:21)7/+436/(cid:22) 8/4+--3928 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--39288/41   #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   49,-72-632/.:3.86/+.(cid:21)(cid:22)  86 ;+8(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22) #78/ 398 46282(cid:21)/(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928(cid:22)   Na rysunku 1.6 widać, że synchronizacja zakończyła się pełnym powodzeniem. Użyli- śmy dodatkowego obiektu 7/+436/, który pełni rolę „strażnika” dostępu do zmiennej +--3928. Jest to jego jedyna rola, do niczego innego nam w tym przykładzie nie służy. Oczywiście nic nie stoi na przeszkodzie, aby użyć obiektu, który jest wykorzystywany w kodzie programu, np. tablicy, jednakże w powyższym ćwiczeniu po prostu nie mieli- śmy takiego pod ręką. Nie możemy natomiast użyć w tym celu zmiennej +--3928 (wszak to byłoby najwygodniejsze), gdyż jest ona typu 28, a instrukcji 72-632/. możemy użyć tylko w stosunku do typów wyprowadzonych z klasy ,/-8. Pokażmy jednak, że do synchronizacji można użyć obiektu, który będzie modyfikowany. Nie musimy wte- dy wprowadzać dodatkowej zmiennej synchronizacyjnej. Aby tego dokonać, musimy napisać własną klasę enkapsulującą zmienną typu 28. To zadanie powinno być zupełnie banalne. 24 Rysunek 1.6. Synchronizacja powiodła się i otrzymany wynik jest teraz prawidłowy Java. Ćwiczenia zaawansowane Ćwiczenie 1.14. Napisz kod klasy --3928 enkapsulującej zmienną typu 28. 49,- -+77--3928  49,-28:+9/  Ćwiczenie 1.15. Dokonaj synchronizacji dostępu do zmiennej +--3928 z ćwiczenia 1.12. Nie używaj dodat- kowego obiektu klasy ,/-8. Zamiast tego zmień typ +--3928 z 28 na --3928 i użyj tego obiektu do synchronizacji. 49,- -+77$6/+./8/2.7$6/+.  46:+8/28;-$6/+. 46:+8/28./+ 46:+8/78+8---3928+--3928 49,-$6/+.(cid:21)28;-$6/+.,28./+(cid:22)  794/6(cid:21)(cid:22) 87 ./+./+ 87 ;-$6/+.;-$6/+.  49,-:3.692(cid:21)(cid:22)  7;8-(cid:21);-$6/+.(cid:22) -+7/ 86/+. (cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+   49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  +--39282/;--3928(cid:21)(cid:22) 2/;$6/+.(cid:21) , (cid:22) 78+68(cid:21)(cid:22) Rozdział 1. L Wątki i programowanie współbieżne w Javie 25 2/;$6/+.(cid:21),(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21), (cid:22) 78+68(cid:21)(cid:22)  49,-:3.86/+. (cid:21)(cid:22)  288/4 036(cid:21)28  11(cid:22) 72-632/.(cid:21)+--3928(cid:22) 8/4+--3928 :+9/ 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--3928 :+9/8/41   #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928 :+9/(cid:22)   49,-:3.86/+.(cid:21)(cid:22)  288/4 036(cid:21)28  11(cid:22) 72-632/.(cid:21)+--3928(cid:22) 8/4+--3928 :+9/ 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)  +--3928 :+9/8/41   #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928 :+9/(cid:22)   49,-72-632/.:3.86/+.(cid:21)(cid:22)  86 ;+8(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22) #78/ 398 46282(cid:21)/(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928 :+9/(cid:22)   Jak widać, obiektem służącym do synchronizacji jest tu +--3928 i jednocześnie jest to obiekt, który modyfikujemy w bloku 72-632/.. Jest to bardzo wygodna metoda, gdyż nie musimy tworzyć dodatkowych zmiennych zaśmiecającyvch system. Skorzystajmy teraz z drugiego sposobu synchronizacji, czyli z metod synchronizowa- nych. Zgodnie z tym, co napisaliśmy powyżej, musimy utworzyć metodę, która będzie modyfikowała obiekt --3928 i zadeklarować ją jako 72-632/.. Może ona wyglądać w sposób następujący: 26 Java. Ćwiczenia zaawansowane 49,-78+8-72-632/.:3.94.+8/--3928(cid:21)(cid:22)  288/4+--3928 :+9/ +--3928 :+9/8/41   Pozostaje teraz wykorzystać ten kod w aplikacji. Ćwiczenie 1.16. Dokonaj synchronizacji dostępu do zmiennej typu --3928. Wykorzystaj synchronizowa- ną metodę 94.+8/--3928(cid:19)(cid:20). 49,- -+77$6/+./8/2.7$6/+.  46:+8/28;-$6/+. 46:+8/28./+ 46:+8/78+8---3928+--3928 49,-$6/+.(cid:21)28;-$6/+.,28./+(cid:22)  794/6(cid:21)(cid:22) 87 ./+./+ 87 ;-$6/+.;-$6/+.  49,-:3.692(cid:21)(cid:22)  7;8-(cid:21);-$6/+.(cid:22) -+7/ 86/+. (cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+ -+7/86/+.(cid:21)(cid:22),6/+   49,-78+8-:3.+2(cid:21)#8621+617(cid:22)  +--39282/;--3928(cid:21)(cid:22) 2/;$6/+.(cid:21) , (cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21),(cid:22) 78+68(cid:21)(cid:22) 2/;$6/+.(cid:21), (cid:22) 78+68(cid:21)(cid:22)  49,-78+8-72-632/.:3.94.+8/--3928(cid:21)(cid:22)  288/4+--3928 :+9/ +--3928 :+9/8/41   49,-:3.86/+. (cid:21)(cid:22)  036(cid:21)28  11(cid:22) 94.+8/--3928(cid:21)(cid:22) #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928 :+9/(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)    Rozdział 1. L Wątki i programowanie współbieżne w Javie 27 49,-:3.86/+.(cid:21)(cid:22)  036(cid:21)28  11(cid:22) 94.+8/--3928(cid:21)(cid:22) #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928 :+9/(cid:22) 86 7//4(cid:21)./+(cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22)    49,-72-632/.:3.86/+.(cid:21)(cid:22)  86 ;+8(cid:21) (cid:22)  -+8-(cid:21)28/66948/.-/4832/(cid:22) #78/ 398 46282(cid:21)/(cid:22)  #78/ 398 46282(cid:21)1/8+/(cid:21)(cid:22)11+--3928 :+9/(cid:22)  
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Ćwiczenia zaawansowane
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ą: