przyk£adowy rozdzia£ java.dz5.pl/ti/materialy/helion java cwiczenia zaawansowane-1.pdf8 java....

Post on 20-Aug-2020

0 Views

Category:

Documents

0 Downloads

Preview:

Click to see full reader

TRANSCRIPT

Wydawnictwo Helionul. Chopina 644-100 Gliwicetel. (32)230-98-63e-mail: helion@helion.pl

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWOŒCIACH

ZAMÓW INFORMACJEO NOWOŒCIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TREŒCISPIS TREŒCI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Java.Æwiczenia zaawansowaneAutor: Marcin LisISBN: 83-7197-947-9Format: B5, stron: 142

Æwiczenia zaawansowane s¹ kolejnym etapem na drodze doskonalenia informatycznychumiejê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 Javieobs³ugiwaæ bazy danych. Napiszemy w³asny, gotowy do praktycznego u¿ycia czat orazaplikacjê do wysy³ania SMS-ów. Nauczymy siê te¿ tworzyæ aplikacje sieciowez  interfejsem graficznym!

Wybrane zagadnienia:

Ksi¹¿ka otwiera now¹ seriê wydawnicz¹, której g³ównym zadaniem bêdzie poszerzenieuzyskanych wiadomoœci.

"

"

"

"

"

"

"

"

"

"

W¹tki i programowanie wspó³bie¿ne w Javie

Synchronizacja w¹tków

Programowanie sieciowe

Czym s¹ gniazda?

Serwer wielow¹tkowy

£¹czenie z baz¹ danych

Dodawanie rekordów

Modyfikacja rekordów w bazie

Obs³uga transakcji i wartoœci null

Aplikacja z interfejsem graficznym

Wstęp...................................................................................................................................................... 5

Rozdział 1. Wątki i programowanie współbieżne w Javie .................................................................... 7

Klasa Thread................................................................................................................. 7

Interfejs Runnable....................................................................................................... 11

Synchronizacja wątków.............................................................................................. 17

Rozdział 2. Programowanie sieciowe..........................................................................................................29

Czym są gniazda? ....................................................................................................... 29

Gniazda w Javie.......................................................................................................... 30

Klient i serwer............................................................................................................. 35

Transmisja danych ...................................................................................................... 39

Serwer wielowątkowy ................................................................................................ 49

Rozdział 3. Aplikacje sieciowe z interfejsem graficznym................................................................ 63

Prawdziwa aplikacja — czat (chat) w Javie................................................................. 63

Chat Serwer ................................................................................................................ 77

Wyślij SMS................................................................................................................. 88

Idea....................................................................................................................... 92

Rozdział 4. Bazy danych....................................................................................................................................... 97

Łączenie z bazą danych .............................................................................................. 97

Dodawanie rekordów................................................................................................ 106

Modyfikacja rekordów w bazie ................................................................................ 112

Obsługa transakcji i wartości null ............................................................................ 120

Aplikacja z interfejsem graficznym.......................................................................... 126

Wątki w Javie reprezentowane są przez klasę ������, znajdującą się w pakiecie �������.Program korzystający z więcej niż jednego wątku możemy utworzyć na dwa sposoby.Albo wyprowadzimy własną, nową klasę z klasy ������, albo też nasza klasa będziemusiała implementować interfejs ������. Zajmijmy się na początku metodą pierwszą.Utworzymy dwie klasy: klasę główną np. ���� i klasę rozszerzającą klasę ������ np.��������. W klasie �������� należy zdefiniować metodę �����, od której rozpocznie siędziałanie wątku; w klasie ���� trzeba utworzyć obiekt klasy �������� i wywołać jegometodę �������. Najlepiej wykonać od razu odpowiedni przykład.

Ćwiczenie 1.1.

Napisz kod klasy �������� dziedziczącej z klasy ������.

������������� ������������ �����

�������� �������

�������������������������

��������������������� ������� ��������

8 Java. Ćwiczenia zaawansowane

Ćwiczenie 1.2.

Napisz kod klasy ���� tworzący wątek ��������.

���������������

�������������������������� �� �!"��

�� ������� ����#��$�� ���������� ���������������������������������� �����������

��

Jeśli spojrzymy teraz na rysunek 1.1, przekonamy się, że oba wątki faktycznie zostaływykonane. Podobny efekt możemy osiągnąć również w nieco inny sposób. Nie trzebatworzyć oddzielnie klasy uruchomieniowej dla wątku (w naszym przypadku była to klasa����). Wystarczy w klasie wyprowadzonej z ������ zdefiniować metodę ���� i tamutworzyć obiekty wątków.

Rysunek 1.1.Wyraźnie widać,

że oba wątki

zostały wykonane

Ćwiczenie 1.3.

Napisz kod klasy �������� wyprowadzonej z klasy ������, uruchamiającej dwa przykła-dowe wątki.

������������� ������������ �����

�������� �������

�������������������������

������������������� ��%���������������������������������� �� �!"��

��$�� �����������������$�� ���������������

��

Rozdział 1. � 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ę��������� klasy ������. 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łównyi wątek klasy ��������. Teraz mamy trzy wątki — wątek główny, którego wykonanierozpoczyna się od metody ������, oraz dwa wątki tworzone przez nas w tej metodzie,których wykonywanie rozpoczyna się od metody �����.

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 teprzekazać jako parametr w konstruktorze klasy ��������, a następnie skorzystać z metody���������.

Ćwiczenie 1.4.

Zmodyfikuj kod z ćwiczenia 1.3 w taki sposób, aby istniała możliwość nadania własnychnazw wątkom.

������������� ������������ �����

�������� ���������� ������

�����������%����������

�����������������

������������������� ��%���������������������������������� �� �!"��

��$�� ������&'��()*�������������$�� ������&'��()+�����������

��

Spróbujmy jednak przekonać się, że rzeczywiście nasze wątki wykonują się niezależnieod siebie. Wystarczy, jeśli dopiszemy pętlę wyświetlającą kilkukrotnie nazwę każdegowątku.

10 Java. Ćwiczenia zaawansowane

Ćwiczenie 1.5.

Napisz przykładowy kod ilustrujący niezależne działanie wątków.

������������� ������������ �����

����������������� ���������� ����,����������

�����������%����������� ��������#������

�����������������

-�������#.��/0��11��������������������� ��%�����������

������������������ �2����������3������������

���������������������������� �� �!"��

��$�� ������4���$�5��,+������������$�� ������6�� ��,*����������

��

Dodatkowo „wyposażyliśmy” nasze wątki w metodę ������, która „usypia” je na zadanąilość milisekund. Dzięki temu możemy spowodować, że każdy z nich wypisuje dane naekran 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. � Wątki i programowanie współbieżne w Javie 11

Wyprowadzanie własnej klasy z klasy ������ 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 istniejeinterfejs ������, który pomoże nam w rozwiązaniu tego problemu.

W interfejsie ������ zdefiniowana jest jedna metoda: �����, od której, podobnie jakw przypadku klasy ������, rozpoczyna się wykonywanie kodu wątku. W celu uruchomie-nia nowego wątku tworzymy nowy obiekt naszej klasy, a następnie używamy go jakoparametru konstruktora klasy ������. Schematycznie wygląda to następująco (zakładając,że ������ implementuje ������):

�7������7����� ������$�7���������$� �������7����� ������

Dostępne konstruktory klasy ������ przedstawione są w tabeli 1.1.

Tabela 1.1. Konstruktory klasy Thread

Konstruktor Opis

� ������ Konstruktor bezparametrowy. Tworzy nowy obiekt klasy � ����

� �����8���������� ��� Tworzy nowy obiekt klasy � ���� związany z obiektem docelowym��� ��

� �����8���������� ��,����� �����

Tworzy nowy obiekt klasy � ���� związany z obiektem docelowym

��� ��, o nazwie ����

� ���������� ����� Tworzy nowy obiekt klasy � ���� o nazwie ����

� ������ ����9���� ����,8���������� ���

Tworzy nowy obiekt klasy � ���� związany z obiektem docelowym

��� ��, przypisany do grupy ����

� ������ ����9���� ����,8���������� ��,����� �����

Tworzy nowy obiekt klasy � ���� o nazwie ����, związany z obiektem

docelowym ��� ��, przypisany do grupy ����

� ������ ����9���� ����,����� �����

Tworzy nowy obiekt klasy � ���� o nazwie ����, przypisany do grupy ����

Ćwiczenie 1.6.

Napisz przykładowy kod ilustrujący niezależne działanie wątków. Skorzystaj z interfejsu ������.

������������������������8��������

�������������� $������������������� $���,����������

� ��������#������� ���$���#$����

12 Java. Ćwiczenia zaawansowane

����������������

-�������#.��/0��11���������������������$���1��1�������

� ����������������������� �2����������3������������

���������������������������� �� �!"��

8�������� ����*#��$������ ����*�,:��8�������� ����+#��$������ ����+�,*����$� ������ ����*������������$� ������ ����+����������

��

Dobrym przykładem wykorzystania interfejsu ������ jest klasa posiadająca interfejsgraficzny. Nie możemy w takim przypadku dziedziczyć bezpośrednio z klasy ������,gdyż np. utworzenie okna wymaga dziedziczenia z klasy �����, a wielodziedziczeniaw Javie nie ma. Stosujemy więc interfejs ������, 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ładoweobliczenia. Stan obliczeń powinien być sygnalizowany użytkownikowi.

������;�����$��<�������;�����$��������<�

���������������������=��������������8�������,>�����?�������,&����$?��������

������������ $ �� � ��������������������@���������������������������@��������������������������?�����4�� �������������������������������������������������� $ �� � ������

��������� ���$ �� � ����#$ �� � ������-�A��������B�����$ �� � �������

�����������&����$?��������� �������?�����������������5��:+.,+..��

������#��$@�������������������������@������C.,*+.,D.,+.��

Rozdział 1. � Wątki i programowanie współbieżne w Javie 13

����������>�����?��������� ����������������

�����#��$@�����������������������@������+..,*+.,D.,+.�����������>�����?��������� ���������������

�4�� ����#��$?������.E����4�� ��������@������*00,D.,F.,+.�������4�� ������

����������3����������������������3�������-������

���G������������������������������

�������#-�����-�������#.��/*..��11��

����� �����������+0.��

����� �2����������3�������������-����������

����(���4�� �������������2��� ���������� ��1*�1�E���

�����������3����������������������3�������-������

��������������������������� �� �!"��

��$�����������������������������4��-������>�����3���������

����� ���#���� ��>�����7����������-������B���������������

����������3�������-�������������#��$�����������������$� ����������������������������3�������������

������-������B��������������

�������#������

�����������$����$6������-����&����$3��������������������$����$7������&����$3��������������������$����$6�����������&����$3���������

14 Java. Ćwiczenia zaawansowane

�����������$����$7����� �&����$3���������

������������.�������������$����$>���������&����$3��������������������$����$2����-����&����$3��������������������$����$H������&����$3����������

Rysunek 1.4.Po kliknięciu

przycisku

Start rozpoczęły

się obliczenia

W metodzie ����� napisaliśmy zwykłą pętlę ��� symulującą wykonywanie jakichś obliczeń.Co 250 milisekund uaktualnia ona tekst etykiety ��������. Wykonywanie tej operacjirozpoczyna 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 ������� wartości����. Wartość tej zmiennej sprawdzana jest cyklicznie, zatem po takim przypisaniu nastąpiprzerwanie działania.

Musimy tutaj zdawać sobie jednak sprawę, że mamy dwa obiekty klasy ����. Jeden z nichtworzony jest w metodzie ������, drugi po naciśnięciu przycisku Start. Zatem jeśli mająone ze sobą współpracować na takiej zasadzie jak przedstawiona powyżej, zmienne������, �����, �������� i ������� muszą być zadeklarowane jako statyczne. Inaczejkaż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 przeszkodzie, aby aplikację tę skonstru-ować w taki sposób, aby wątek był tworzony znanym nam już sposobem, przez oddzielnąklasę, pochodną od ������.

Ćwiczenie 1.8.

Napisz kod klasy �������� symulującej wykonywanie obliczeń i współpracującej z klasą���� realizującą interfejs graficzny.

������������� ������������ �����

������������������������������������������ ��������������,���������

Rozdział 1. � Wątki i programowanie współbieżne w Javie 15

���������� ��������#������� ���������#�������

�����������������

�������#-�����-�������#.��/*..��11��

�����������������

����� �2����������3�������������-����������

����(����������4�� �������������2��� ���������� ��1*�1�E���

��

Metoda ����� 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ą������, która jest referencją do obiektu klasy ���� i umożliwia nam komunikację z nim.Dzięki temu możemy modyfikować tekst pojawiający się na ekranie. Musimy w tej chwilitylko przystosować klasę ���� do współpracy z naszym nowym wątkiem.

Ćwiczenie 1.9.

Napisz kod klasy ���� wykorzystującej przygotowaną w ćwiczeniu 1.8 klasę wątku.

������;�����$��<�������;�����$��������<�

���������������������=��������������>�����?�������,&����$?��������

���������@���������������������@��������������������?�����4�� ���������������� ����� �����������������

��������

���&����$?��������� �������?�����������������5��:+.,+..��

������#��$@�������������������������@������C.,*+.,D.,+.������������>�����?��������� ����������������

16 Java. Ćwiczenia zaawansowane

�����#��$@�����������������������@������+..,*+.,D.,+.�����������>�����?��������� ���������������

�4�� ����#��$?������.E����4�� ��������@������*00,D.,F.,+.�������4�� ������

����������3����������������������3�������-������

���G���������������������������������������� �� �!"��

��$�����������������������4��-������>�����3���������

����� ���#���� ��>�����7����������-������B���������������

����������3�������-������� ����#��$�� ������ ��,+0.��� ����������������������3�������������

������-������B��������������

� ������������#���������������3����������������������3�������-������

������������$����$6������-����&����$3��������������������$����$7������&����$3��������������������$����$6�����������&����$3��������������������$����$7����� �&����$3���������

������������.�������������$����$>���������&����$3��������������������$����$2����-����&����$3��������������������$����$H������&����$3����������

Rozdział 1. � 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ątkimodyfikujące jej wartość. Załóżmy, że będzie to dodawanie w pętli w każdym przebieguwartoś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 ���.

������������� ������������ �����

����������$ �� � ��������������������������������������������#.��������� ��������$ �� � ����,����������

��������� ��������#������� ���$ �� � ����#$ �� � �����

�����������������

�$��� �$ �� � ����������*�� ����*�������(�����+�� ����+�������(�����:�� ����:�������(�

���������������������������� �� �!"��

��$�� �����*,*������������$�� �����+,+������������$�� �����:,.����������

������������ ����*���

-�������#.��/*.��11������

������������������ �2����������3�������������������11�

������������� ����+���

-�������#.��/*.��11������

�������������

18 Java. Ćwiczenia zaawansowane

����� �2����������3�������������������11�

������������ ����5������� ����:���

����$����*...��

����� �2����������3�����������

������������������������������������������ ��%�����1��1���������

��

Wątki ������ i ������! zajmują się zwiększaniem wartości zmiennej �""����. Jedynymzadaniem wątku ������# jest odczekanie 1 000 milisekund i wyświetlenie wartości zmiennej�""����. 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 �""���� będzie w postaci �""����$%�""����$&$ ? Napiszmy taki program.

Ćwiczenie 1.11.

Zmodyfikuj kod z ćwiczenia 1.10 w taki sposób, aby modyfikacja zmiennej �""���� byław postaci: �""����$%$�""����$&$ .

������������� ������������ �����

����������$ �� � ��������������������������������������������#.��������� ��������$ �� � ����,����������

��������� ��������#������� ���$ �� � ����#$ �� � �����

�����������������

�$��� �$ �� � ����������*�� ����*�������(�����+�� ����+�������(�����:�� ����:�������(�

���������������������������� �� �!"��

��$�� �����*,*������������$�� �����+,+������������$�� �����:,.����������

Rozdział 1. � Wątki i programowanie współbieżne w Javie 19

����������� ����*���

-�������#.��/*.��11������

������������������ �2����������3�������������������#�������1*�

������������� ����+���

-�������#.��/*.��11������

������������������ �2����������3�������������������#�������1*�

������������ ����5������� ����:���

����$����*...��

����� �2����������3�����������

������������������������������������������ ��%�����1��1���������

��

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 terazod kompilatora. Jeśli jest on „inteligentny”, prawdopodobnie potraktuje instrukcję �""����%$�""����$&$ jako �""����&&. W takim wypadku faktycznie program będzie prawi-dłowy, gdyż �""����&& jest instrukcją atomową, tzn. nie może być ona przerwana przezinny wątek. Niestety nie należy przyjmować takiego założenia, natomiast trzeba traktowaćtaki kod jako złożenie następujących operacji:

� pobranie wartości �""����,

� dodanie do tej wartości 1,

� zapisanie otrzymanej wartości do zmiennej �""����.

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:

� wartość zmiennej �""���� będziemy modyfikować w dwóch krokach,

� pomiędzy poszczególnymi operacjami dodamy instrukcję ������, usypiającą danywątek.

20 Java. Ćwiczenia zaawansowane

Kod w każdym wątku powinien zatem wyglądać następująco:

��������-�������#.��/*.��11��

����#������������

������������������ �2����������3�������������������#����1*�������������������� ��%�����1��1���������

Ćwiczenie 1.12.

Napisz program wymuszający wzajemne przerywanie pracy wątków przy modyfikacjiwspólnej zmiennej typu ���.

������������� ������������ �����

����������$ �� � ��������������������������������������������#.��������� ��������$ �� � ����,����������

��������� ��������#������� ���$ �� � ����#$ �� � �����

�����������������

�$��� �$ �� � ����������*�� ����*�������(�����+�� ����+�������(�����:�� ����:�������(�

���������������������������� �� �!"��

��$�� �����*,*������������$�� �����+,+������������$�� �����:,.����������

������������ ����*���

��������-�������#.��/*.��11��

����#������������

������������������ �2����������3�������������������#����1*�������������������� ��%�����1��1���������

Rozdział 1. � Wątki i programowanie współbieżne w Javie 21

������������ ����+���

��������-�������#.��/*.��11��

����#������������

������������������ �2����������3�������������������#����1*�������������������� ��%�����1��1���������

������������ ����5������� ����:���

����$����*...��

����� �2����������3�����������

������������������������������������������ ��%�����1��1���������

��

Instrukcje ��������������� dokładnie pokazują nam, co się dzieje. Wynik oczywiścienie jest prawidłowy, gdyż pomiędzy pobraniem wartości �""���� a jej modyfikacjąi ponownym zapisaniem w każdym wątku występuje przerwa, umożliwiająca wykonanieoperacji 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 ���"�����'��. Możemy ją stosować zarównow przypadku metod (ang. synchronized methods), jak i obiektów. Jeżeli zadeklarujemymetodę jako ���"�����'��, np.:

22 Java. Ćwiczenia zaawansowane

���������� ����5������� �$���

������(�;�

to wywołanie takiej metody powoduje zablokowanie obiektu, na rzecz którego jest onawywoływana. Obiekt ten będzie zablokowany, aż do zakończenia wykonywania tejżeinstrukcji i inne wątki nie będą miały do niego dostępu. Druga metoda to zablokowanieobiektu w postaci:

���� ����5�������(���

������(�;�

przy czym obiekt użyty do synchronizacji nie musi być użyty w bloku instrukcji. Spró-bujmy zatem zsynchronizować dostęp do zmiennej �""���� z poprzedniego ćwiczenia.

Ćwiczenie 1.13.

Dokonaj synchronizacji dostępu do zmiennej �""���� z ćwiczenia 1.12.

������������� ������������ ����

����������$ �� � ���������������������

�����������������������#.�

�������������H�;�������� ����

�������� ��������$ �� � ����,����������

��������

� ��������#������� ���$ �� � ����#$ �� � �����

����������������

�$��� �$ �� � ������

����*�� ����*�������(�����+�� ����+�������(�

����:�� ����:�������(�

��������������������������� �� �!"�

����� ���#��$H�;��������$�� �����*,*����������

��$�� �����+,+����������

��$�� �����:,.�����������

����������� ����*��

��������-�������#.��/*.��11��

���� ����5�������� �����

����#��������

Rozdział 1. � Wątki i programowanie współbieżne w Javie 23

�����������������

���� �2����������3������������

�������#����1*�

������������������� ��%�����1��1����������

����������� ����+���

��������

-�������#.��/*.��11������ ����5�������� �����

����#��������

����

��������������

���� �2����������3�����������

��������#����1*�

������������������� ��%�����1��1����������

���������� ����5������� ����:��

�����

$����*...��

����� �2����������3�����������

����������������������

�������������������� ��%�����1��1���������

Na rysunku 1.6 widać, że synchronizacja zakończyła się pełnym powodzeniem. Użyli-śmy dodatkowego obiektu ���������, który pełni rolę „strażnika” dostępu do zmiennej�""����. 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 wykorzystywanyw 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 �""���� (wszakto byłoby najwygodniejsze), gdyż jest ona typu ���, a instrukcji ���"�����'�� możemyużyć tylko w stosunku do typów wyprowadzonych z klasy (���"�. 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ć, musimynapisać własną klasę enkapsulującą zmienną typu ���. To zadanie powinno być zupełniebanalne.

24 Java. Ćwiczenia zaawansowane

Rysunek 1.6.Synchronizacja

powiodła się

i otrzymany

wynik jest

teraz prawidłowy

Ćwiczenie 1.14.

Napisz kod klasy )""���� enkapsulującej zmienną typu ���.

�����������>�������

����������������

Ćwiczenie 1.15.

Dokonaj synchronizacji dostępu do zmiennej �""���� z ćwiczenia 1.12. Nie używaj dodat-kowego obiektu klasy (���"�. Zamiast tego zmień typ �""���� z ��� na )""���� i użyj tegoobiektu do synchronizacji.

������������� ������������ �����

����������$ �� � ����������������������������������>����������������������� ��������$ �� � ����,����������

��������� ��������#������� ���$ �� � ����#$ �� � �����

�����������������

�$��� �$ �� � ����������*�� ����*�������(�����+�� ����+�������(�����:�� ����:�������(�

���������������������������� �� �!"��

�������#��$>�����������$�� �����*,*����������

Rozdział 1. � Wątki i programowanie współbieżne w Javie 25

��$�� �����+,F������������$�� �����:,.����������

������������ ����*���

��������-�������#.��/*.��11��

���� ����5����������������#������������������

������������������ �2����������3�������������������������#����1*�

�������������������� ��%�����1��1���������������

������������� ����+���

��������-�������#.��/*.��11��

���� ����5����������������#������������������

������������������ �2����������3�������������������������#����1*�

�������������������� ��%�����1��1���������������

������������ ����5������� ����:���

����$����*...��

����� �2����������3�����������

������������������������������������������ ��%�����1��1���������������

��

Jak widać, obiektem służącym do synchronizacji jest tu �""���� i jednocześnie jest toobiekt, który modyfikujemy w bloku ���"�����'��. Jest to bardzo wygodna metoda, gdyżnie musimy tworzyć dodatkowych zmiennych zaśmiecających 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ędziemodyfikowała obiekt )""���� i zadeklarować ją jako ���"�����'��. Może ona wyglądaćw sposób następujący:

26 Java. Ćwiczenia zaawansowane

���������������� ����5������������>���������

�������#���������������������������#����1*�

Pozostaje teraz wykorzystać ten kod w aplikacji.

Ćwiczenie 1.16.

Dokonaj synchronizacji dostępu do zmiennej typu )""����. Wykorzystaj synchronizowa-ną metodę ������)""������.

������������� ������������ �����

����������$ �� � ����������������������������������>����������������������� ��������$ �� � ����,����������

��������� ��������#������� ���$ �� � ����#$ �� � �����

�����������������

�$��� �$ �� � ����������*�� ����*�������(�����+�� ����+�������(�����:�� ����:�������(�

���������������������������� �� �!"��

�������#��$>�����������$�� �����*,*������������$�� �����+,F������������$�� �����:,.����������

����������������� ����5������������>���������

�������#���������������������������#����1*�

������������ ����*���

-�������#.��/*.��11��������>���������������������������� ��%�����1��1�������������������

������������������ �2����������3������������

��

Rozdział 1. � Wątki i programowanie współbieżne w Javie 27

����������� ����+���

-�������#.��/*.��11��������>���������������������������� ��%�����1��1�������������������

������������������ �2����������3������������

������������ ����5������� ����:���

����$����*...��

����� �2����������3�����������

������������������������������������������ ��%�����1��1���������������

��

top related