Java: Visibility problem

0:00Cześć witam cię bardzo serdecznie w

0:04tej lekcji już zaczniemy zajmować tym jak implementować

0:09bezpiecznie kod który jest wielowątkowy tak do tej pory nauczyliśmy

0:13się jak używać future'ów executorów i tak dalej a teraz zobaczymy jak

0:17to zrobić żeby faktycznie mieć to thread safety sposób w jaki

0:21będziemy się uczyli to będzie taki że ja będę prezentował pewien problem kawałek

0:25kodu który powinien działać ale z jakiegoś powodu nie działa oraz

0:30zobaczymy jak jesteśmy w stanie go poprawić w tej lekcji zajmiemy

0:34się czymś co się nazywa visibility problem zacznijmy

0:38od kodu mamy jakiś fragment kodu jest tutaj pewien taki pattern

0:42służący do zatrzymywania wątku który jest powiedzmy sterowany

0:46z zewnątrz jakąś zmienną tak tu mamy jakąś flagę i ten wątek

0:50zaczyna swoją pracę ma tutaj jakiegoś takiego infinite loop'a który się zakończy

0:54w momencie kiedy z zewnątrz ustawimy stop tak stop jest tutaj niestety

0:59zmienną mutowalną z zewnątrz tak czyli jest współdzieloną zmienną mutowalną

1:04okej czyli startujemy wątek on tutaj mieli w nieskończoność

1:08do momentu kiedy my tutaj odczekamy sekundę i ustawimy mu true tak i

1:13później kończy się main i powiedzmy ten wątek też już powinien być zakończony mniej więcej powinno

1:17działać intuicyjnie wydaje się że powinno zajrzymy teraz co tu się wydarzy i

1:22jak widzimy nasz menu się zakończył no ale program się nie zakończył

1:26tak nie mamy wyświetlonej tej frazy tak tego zdania no okej

1:30i co to się teraz zadziałało problem polega na tym że w momencie

1:34tworzenia tego thread'u tutaj dostajemy coś co możemy sobie wyobrażać

1:39jako snapshot zmiennej tak dostajemy stopa ustawionego na false

1:43i w momencie kiedy my tutaj ustawiamy na true to

1:47ten wyjątek nawet tego nie widzi on tu jest jakoś tak zafiksowany że patrzy

1:52cały czas na ten tak może też być tak że ustawienie tego powiedzmy

1:56ustawia tą zmienną tak jakby tylko dla tego wątku tak to jest tak zwane

2:01przekraczanie memory barrier możemy sobie wyobrazić że każdy

2:05thread który tworzymy ma pewnego rodzaju snapshot wszystkich

2:09zmiennych tak no i teraz jeżeli my zmieniamy coś w jednym threadzie to

2:13nawet nie może nie być zapisane do jakiejś powiedzmy main memory tylko

2:18gdzieś tutaj lokalnie sobie jest zapisane tak i teraz odczyt w drugim

2:22wątku może tego w ogóle nie zauważyć może w ogóle nie przechodzi do main memory tylko

2:26szuka sobie jakąś taką powiedzmy thread local version tak coś takiego

2:30okej i teraz główny problem z tym

2:34z tym visibility problem jest taki że to czasami działa

2:39a czasami nie tutaj jak coś zauważysz ja ten w ogóle ten fragment

2:43kodu ja musiałem trochę poeksperymentować żeby doprowadzić do tego żeby mieć

2:47ten efekt ze on teraz nie wyłącza tego wątku tak na

2:51innej platformie powiedzmy na jakimś innym jvm na jakimś innym komputerze

2:55mogłoby być tak że optymalizator javy w ogóle by tego powiedzmy

2:59na nim by to zadziałało w sensie on by zauważył że okej stop

3:04się zmienił tak zauważ sobie że na przykład jak ja tutaj dodam jakąś linijkę

3:08to przypadkowo zupełnie w tym momencie teraz zachowa się tak

3:12jakbyśmy tego chcieli tak to jest przypadkowe i oczywiście

3:17trochę specyficzne to wynika z pewno jakiś taki implementacji pod spodem która

3:21może się zmienić która może brać pod uwagę wiele jakichś takich zmiennych związanych z

3:25platformą prawda w każdym razie łatwiej jest wymusić żeby on powiedzmy omijał

3:29to memory barrier niż wymusić żeby nie ominą tak okej

3:33teraz pokażę ci trzy sposoby w jakie jesteśmy sobie w stanie z tym poradzić

3:38tak ich jest więcej ale te nam powinny zupełnie wystarczyć pierwszy

3:42sposób w jaki jesteśmy w stanie sobie poradzić tutaj to jest dodanie modyfikatora

3:47volatile dalej do tej zmiennej dzięki temu każdy zapis i odczyt tej

3:51zmiennej będzie przekraczał właśnie tą barierę pamięci tak czyli

3:55będzie zapisywał we właściwe miejsce i odczytywał zawsze

3:59tą oryginalną wartość teraz zobaczymy sobie jak teraz zadziała nasz kod i jak

4:03widzimy kod zakończył się prawidłowo tak mamy tutaj zakończyliśmy

4:07maina i też ten też został zakończony prawda zauważ że volatile

4:12on też nie załatwia sprawy zapisu synchronizacji

4:17do tego do tej zmiennej tak on tylko tutaj w tym momencie zapewnia

4:21że zapiszemy właściwą wartość tak we właściwe miejsce i to będzie widoczne

4:25dla innych wątków taka jest powiedzmy gwarancja tego czegoś kolejnym

4:30sposobem jest wykorzystanie pewnego wrappera jest to atomic boolean

4:34powiedzmy to jest obiekt z tego względu możemy tutaj też zastosować final to

4:38jest też całkiem fajne tworząc atomic boolean my tutaj mu wskazujemy jakąś

4:42inicjalna wartość tego obiektu później możemy po prostu zrobić na

4:46tym stop ta sztuczka polega na tym że atomic boolean w środku

4:50trzyma boola po prostu tak to jest pewien wrapper a właściwie

4:55nawet inta tak ale on przede wszystkim i jest volatile tak czyli

4:59też zapewnia przekraczanie tej memory barrier tak

5:03okej to też nam zadziała tym momencie poza tym że mamy

5:07powiedzmy wrappera tak że mamy to volatile i to też atomic boolean oraz

5:11inne wrappery to na przykład atomic integer atomic long i

5:15tak dalej też dodają kilka metod które zapewniają nam atomowe

5:19operacje na tych zmiennych tak które są pod spodem one są mutowalne

5:25wewnętrznie ale jesteśmy powiedzmy w stanie odpowiednio tam jakoś

5:29zmanipulować i mieć powiedzmy takie atomowe operacje tak na przykład

5:33możemy na atomic longu możemy atomowo implementować go tak

5:37co jest thread safety tak wtedy oczywiście jeszcze pytanie

5:42do czego to użyjemy okej lecimy dalej ostatnim z prezentowanych

5:46sposobów jest wykorzystanie takiego modyfikatora synchronized

5:50synchronized możemy tworzyć i powiedzmy tworzyć to na jakimś bloku

5:55kodu ale możemy też na metodzie i teraz synchronized robi coś takiego jeżeli mamy

5:59jakąś metodę tutaj to do środka może wejść tylko jeden wątek tak

6:03tutaj i tutaj może wejść jeden wątek naraz jak on

6:07skończy powiedzmy swoje wykonanie no to może wejść drugi ale drugim takim powiedzmy

6:12efektem jest to że jeżeli robimy synchronized przy

6:17zapisie i odczycie danej zmiennej która powiedzmy jest mutowalna

6:21to teraz mamy gwarancję że zostanie przekroczone właśnie memory barrier

6:25jak sobie zobaczymy to też nam zadziała okej synchronized jest też wykorzystywany

6:29do synchronizowania zapisu i odczytu na przykład jeżeli mamy jakąś operację która

6:33wymaga najpierw odczytania zmiennej wykonania jakiejś logiki jak podjęcia jakiejś

6:37decyzji później jeszcze raz zapisania do tej zmiennej tutaj jeżeli chcemy uniknąć tak

6:41zwanego race conditions możemy też wykorzystać właśnie synchronized ale o tym dowiemy się

6:45też w kolejnych lekcjach okej czyli podsumowując możemy wykorzystać

6:50sobie volatile co jest takim powiedzmy takim najbardziej niskopoziomowy modyfikatorem

6:54takim rozwiązanie w tej kwestii możemy wykorzystać sobie synchronized możemy

6:58też wykorzystać wrapper jakim jest atomic boolean tak oczywiście

7:02tutaj w tym patternie też zauważ że jak mieliśmy tutaj w ogóle ten pattern

7:06że chcemy zastopować jakąś wykonanie jakiegoś threada jakichś operacji

7:10z poziomu jakiegoś innego thread'a który utworzył też ten wątek i ma

7:15dostęp do tego wątku w ogóle tak to możemy też tutaj zastosować

7:19ten patent interrupt tak i w tym momencie sprawdzać current thread

7:23is interrupted tak i odpowiednio w zależności od tego reagować

7:28tak i zakończ na przykład pracę okej jeżeli chodzi o visibility problem

7:32no to jest wszystko dzięki wielkie za uwagę i do zobaczenia w kolejnej lekcji