1
00:00:02,030 --> 00:00:04,370
Ciao, questo è determinato a farlo.

2
00:00:04,460 --> 00:00:10,200
Ora diamo un'occhiata al modificatore volatile che può essere usato con Berryman nella lezione precedente.

3
00:00:10,370 --> 00:00:16,490
Abbiamo visto che spesso accade prima che le regole di ordinamento fossero basate su variabili volatili.

4
00:00:16,670 --> 00:00:23,430
Uno è semplicemente un modificatore che viene utilizzato con le variabili e aiuta a garantire la visibilità della memoria.

5
00:00:23,460 --> 00:00:24,950
Questo è una volta un thread particolare.

6
00:00:24,970 --> 00:00:27,290
Giusto quindi sarai una variabile volatile.

7
00:00:27,430 --> 00:00:34,090
È garantito che il valore particolare sarebbe visibile a tutti i successivi saluti della tabella di query

8
00:00:34,130 --> 00:00:35,990
da tutte le minacce.

9
00:00:36,040 --> 00:00:41,300
Questo è ciò che è stato menzionato nella lezione precedente e potrebbe essere una

10
00:00:41,340 --> 00:00:48,130
variabile volatile stabilire come accade prima di ordinare, ma i successivi trucchi della stessa variabile indipendentemente dal thread che

11
00:00:48,130 --> 00:00:49,960
sta eseguendo la lettura.

12
00:00:50,440 --> 00:00:55,210
Quindi il valore della variabile volatile verrà propagato a tutti gli altri thread.

13
00:00:55,420 --> 00:01:01,780
È un normale dibattito per evitare la sincronizzazione della visibilità della memoria, aiuterebbe anche a farlo nel modo giusto.

14
00:01:01,780 --> 00:01:03,080
L'abbiamo già visto.

15
00:01:03,610 --> 00:01:09,400
E se si guarda al dizionario il significato di bene è qualcosa che cambia molto

16
00:01:09,460 --> 00:01:10,840
rapidamente e imprevedibile.

17
00:01:12,350 --> 00:01:18,040
Quali sono i valori idonei vengono sempre memorizzati nella memoria principale in modo che non vengano memorizzati nella cache e che

18
00:01:18,040 --> 00:01:20,570
i registri siano nei processori della cache locale.

19
00:01:20,770 --> 00:01:26,290
Quindi credo che semplifica i criteri di visibilità della memoria dato che stiamo trattando solo la memoria

20
00:01:26,290 --> 00:01:31,920
principale che ogni processore scriverà sempre un valore di variabile qualitativa alla memoria principale e vorrà leggerli

21
00:01:31,930 --> 00:01:33,110
nella memoria principale.

22
00:01:34,620 --> 00:01:41,030
Quale piccola parola chiave può essere usata con variabili mutabili condivise, non che la parola chiave volatile non possa essere

23
00:01:41,030 --> 00:01:47,100
usata con variabili locali come l'ambito delle variabili locali e con il blocco in cui sono definite.

24
00:01:47,180 --> 00:01:50,930
Quindi non ha senso.

25
00:01:51,010 --> 00:01:57,310
Ed ecco un tipico caso d'uso di una variabile volatile e il codice è adattato dalla voce 5:54 a un

26
00:01:57,310 --> 00:01:58,120
Java efficace.

27
00:01:58,450 --> 00:02:01,840
Qui l'obiettivo è fermare un thread sotto questa corte.

28
00:02:01,870 --> 00:02:03,040
Ci sono due thread.

29
00:02:03,040 --> 00:02:08,710
Uno è il thread principale e l'altro è mostrato nella casella grigia dove stiamo usando una classe

30
00:02:08,830 --> 00:02:10,440
anonima per implementare quell'attività.

31
00:02:10,870 --> 00:02:17,170
È inoltre possibile notare l'invocazione della dichiarazione che questo esempio mostra un coordinamento rigoroso dal

32
00:02:17,170 --> 00:02:18,090
thread principale.

33
00:02:18,190 --> 00:02:24,750
Vogliamo fermare il secondo thread e per questo stiamo usando la variabile mutabile condivisa chiamata Stop.

34
00:02:24,890 --> 00:02:32,050
Sotto è dichiarato come volatile e ha un valore predefinito AHA, non il secondo thread ha un loop all'interno del

35
00:02:32,050 --> 00:02:32,730
ciclo.

36
00:02:32,740 --> 00:02:38,760
Stiamo stampando del testo undealt stop è impostato su true dopo circa un secondo.

37
00:02:38,760 --> 00:02:40,800
Il set di thread principale si è fermato.

38
00:02:40,870 --> 00:02:46,680
Vero, ma questo è quando leggo il secondo thread ritorna nello stato di esecuzione nel caso in cui

39
00:02:46,680 --> 00:02:52,210
la condizione non dovesse riuscire e la terza terminerebbe la variabile azionaria non dichiarata come volatile.

40
00:02:52,370 --> 00:02:58,870
Quindi non vi è alcuna garanzia che il secondo thread vedrà mai il valore aggiornato o si fermerà

41
00:02:58,890 --> 00:03:00,480
e sarà infinitamente nuovo.

42
00:03:00,770 --> 00:03:05,520
Quindi, cosa stai stabilendo che accada prima di ordinare su questo.

43
00:03:05,540 --> 00:03:13,110
Consentendo ai due thread di coordinarsi in modo efficace e qui è lo stesso esempio ma utilizzando la sincronizzazione sappiamo

44
00:03:13,840 --> 00:03:18,120
che la sincronizzazione stabilisce anche che avviene prima di ordinare.

45
00:03:18,510 --> 00:03:24,690
Quindi si ferma è impostato su true all'interno del metodo sincronizzato chiamato stop di richiesta che viene richiamato dal

46
00:03:24,690 --> 00:03:25,640
metodo principale.

47
00:03:26,100 --> 00:03:32,730
Allo stesso modo c'è anche il metodo sincronizzato per fermare i bit che legge semplicemente l'ultimo stop di Radulov

48
00:03:32,730 --> 00:03:35,840
e questo metodo è accessibile dal secondo terzo.

49
00:03:35,950 --> 00:03:42,020
Quindi, una volta che l'interruzione delle richieste viene invocata da Main, il metodo di stop successivo viene richiamato con un secondo thread.

50
00:03:42,230 --> 00:03:45,760
Il secondo thread mentre la condizione fallirà e raramente terminerà.

51
00:03:46,230 --> 00:03:50,760
Quindi la sincronizzazione fa anche tutto ciò che fa.

52
00:03:50,810 --> 00:03:54,370
Tuttavia, secondo il blocco di Joshuah, sembra che le prestazioni siano sagge.

53
00:03:54,410 --> 00:03:56,610
Una piccola domanda potrebbe essere migliore.

54
00:03:56,700 --> 00:04:00,950
E ovviamente è anche molto più leggibile senza i due metodi aggiuntivi.

55
00:04:02,870 --> 00:04:09,750
Ora, anche nel nostro esempio di conto bancario, abbiamo visto il vantaggio della visibilità di Mammootty a causa della sincronizzazione.

56
00:04:09,800 --> 00:04:14,040
Sappiamo che Anita Austrade riesce a vedere l'ultimo round fuori equilibrio.

57
00:04:14,040 --> 00:04:20,730
Se gli accessi alla frequenza cardiaca ottengono il bilanciamento methhead dopo Jon Stewart ablate equilibrio nella marca

58
00:04:20,740 --> 00:04:27,880
con Dolemite che, oltre alla sincronizzazione della visibilità della memoria, garantisce anche l'esclusione reciproca che si trova in

59
00:04:27,880 --> 00:04:29,320
un dato momento.

60
00:04:29,380 --> 00:04:35,830
Solo un thread può accedere ai metodi Synchronize ottenere il bilanciamento e fare con dawn sul Tedward rilasciare il

61
00:04:35,830 --> 00:04:38,750
lock solo dopo essere usciti da quel punto.

62
00:04:39,180 --> 00:04:45,950
E questo è necessario perché vogliamo che il metodo Dawley funzioni correttamente atomicamente e se non usiamo

63
00:04:45,950 --> 00:04:46,990
sicuramente Synchronoss.

64
00:04:47,170 --> 00:04:53,500
Ma se semplicemente rendiamo volatile una variabile volatile, otteniamo la visibilità di Mammootty, ma avremmo comunque la condizione

65
00:04:53,500 --> 00:04:56,150
di gara se prenotata su di essa.

66
00:04:56,160 --> 00:05:02,670
Noi e Jon Stewart ci stiamo ritirando nello stesso momento, quindi abbiamo bisogno di essere bloccati qui.

67
00:05:04,190 --> 00:05:11,210
Quindi, in sostanza, il blocco della sincronizzazione può arrivare in profondità, ma la visibilità della memoria e l'esclusione

68
00:05:11,620 --> 00:05:16,830
reciproca mentre la variabile volatile può solo garantire la visibilità della memoria.

69
00:05:16,990 --> 00:05:23,260
Se c'è un singolo thread che è giusto in una variabile condivisa su altri thread, leggi il valore di

70
00:05:23,260 --> 00:05:24,260
quella variabile.

71
00:05:24,340 --> 00:05:30,740
Quindi non vi è alcuna questione di condizioni di gara e possiamo usare variabili a coda di rondine nel nostro esempio tappato.

72
00:05:30,740 --> 00:05:35,950
Avevamo il thread principale che impostava la variabile condivisa stop su true nel secondo.

73
00:05:35,980 --> 00:05:37,790
Stavo leggendo quel valore.

74
00:05:37,840 --> 00:05:44,260
Quindi, quale stile è un candidato perfetto per quello in quel particolare esempio anche se ci fossero più thread

75
00:05:44,260 --> 00:05:51,510
che cercano la variabile condivisa non è vero allora possiamo ancora usarne uno visto che tutti i thread stanno impostando una variabile

76
00:05:51,510 --> 00:05:53,630
di stop con lo stesso valore.

77
00:05:53,630 --> 00:06:01,160
Vero e quindi non dovrebbe importare, ma se ci può essere una condizione seria, non possiamo usare volatile e

78
00:06:01,370 --> 00:06:08,570
dobbiamo sincronizzare il nostro esempio di conto bancario con solo Donjon ha un controllo quindi agisce sulle condizioni

79
00:06:08,870 --> 00:06:11,460
e dobbiamo usare la sincronizzazione lì.

80
00:06:11,480 --> 00:06:19,090
Ovviamente otteniamo anche il beneficio della visibilità della memoria per ascoltare qualcosa di più sulla semantica di

81
00:06:19,140 --> 00:06:25,030
Mammootty, sono tutte azioni che precedono o che non nutro o non rilascia.

82
00:06:25,030 --> 00:06:32,010
Anche Locke è visibile a tutte le azioni che dopo una successiva lettura della scena non erano insopportabili.

83
00:06:32,140 --> 00:06:34,300
La nostra acquisizione della stessa serratura.

84
00:06:34,750 --> 00:06:39,410
Non è chiaro quindi la prossima illustrazione dovrebbe essere utile.

85
00:06:39,510 --> 00:06:43,460
Vediamo come, a sua volta.

86
00:06:43,660 --> 00:06:50,870
Abbiamo alcune azioni e quelle azioni precedono leggermente o Walton Feed o rilascio tutto insieme.

87
00:06:52,510 --> 00:06:59,970
Timestamp non-literate successivo dobbiamo leggere il quale Ada legge dallo stesso wallet su richiesta lo stesso lock

88
00:06:59,970 --> 00:07:07,540
che è stato rilasciato in precedenza ma che tutte le precedenti azioni che abbiamo visto nel cloud

89
00:07:07,540 --> 00:07:10,400
saranno visibili anche al thread B.

90
00:07:12,060 --> 00:07:17,190
Diamo un'occhiata a un esempio ora e guardalo già nel contesto di Wallack.

91
00:07:17,760 --> 00:07:24,690
Vediamo se aiutiamo il thread a lanciare un bit in qualche istante di tempo su un accesso all'abisso

92
00:07:24,690 --> 00:07:27,520
X e facciamo 10 e 15 rispettivamente.

93
00:07:27,630 --> 00:07:29,600
Qui siamo una variabile volatile.

94
00:07:29,650 --> 00:07:34,690
È una variabile regolare accanto a un'istanza temporale successiva.

95
00:07:34,800 --> 00:07:45,760
Non essere lanciato successivamente da un'istanza Il thread D-3 viene riassegnato in Leva extra la volta successiva che l'istante precedente non può essere letto

96
00:07:46,190 --> 00:07:50,290
X ma vede ancora il valore come allora.

97
00:07:50,750 --> 00:07:58,020
Quindi non vedendo il nuovo valore all'istante di tempo il thread di combattimento aggiorna la variabile volatile

98
00:07:58,020 --> 00:08:04,980
v il 16 e infine un'istanza di tempo D6 non può essere raggiunta una variabile volatile.

99
00:08:05,300 --> 00:08:14,120
E poi legge x con quell'ottimo battito arriva a vedere i valori più recenti sia di x che di x.

100
00:08:14,270 --> 00:08:20,930
Quindi, come puoi vedere leggendo la variabile variabile di rollergirl, B è anche in grado di vedere il valore

101
00:08:20,930 --> 00:08:22,460
più recente di x.

102
00:08:22,680 --> 00:08:23,970
Quindi questo è tutto.

103
00:08:23,970 --> 00:08:29,950
Sappiamo capire quale variabile volatile si trova nella sincronizzazione della visibilità della memoria di B,

104
00:08:29,950 --> 00:08:30,830
d'altra parte.

105
00:08:30,870 --> 00:08:35,510
Ho ottenuto la visibilità della memoria del libro così come in città.

106
00:08:35,580 --> 00:08:36,120
No, non lo è.

107
00:08:36,120 --> 00:08:36,930
30 secondi.

108
00:08:37,120 --> 00:08:45,770
Facciamo una rapida demo di tutto il programma Star Trek OK ecco un nuovo thread di stop di classe su di esso è stato aggiunto

109
00:08:45,770 --> 00:08:52,340
con un pacchetto di concorrenza e possiamo vedere qui la variabile stop su Vollertsen e tutto il resto è

110
00:08:52,340 --> 00:08:53,270
lo stesso.

111
00:08:53,270 --> 00:08:58,550
Abbiamo due thread il thread principale sul secondo thread e quindi è stato più lucido.

112
00:08:58,820 --> 00:09:00,710
Quindi il thread principale dopo circa 1 secondo.

113
00:09:00,710 --> 00:09:03,530
Qui è qualcosa di veramente sbagliato.

114
00:09:03,550 --> 00:09:08,720
Il secondo thread non appena si ferma, la vite sta per terminare.

115
00:09:08,750 --> 00:09:09,420
Quindi sono io.

116
00:09:09,430 --> 00:09:14,070
Corri a correre ora che è finito.

117
00:09:14,410 --> 00:09:15,460
Quindi questo è tutto.

118
00:09:15,460 --> 00:09:21,120
Puoi andare avanti e puoi anche scaricare questo programma dalla sezione sorgente e puoi rimuovere la parola

119
00:09:21,470 --> 00:09:25,320
chiave qui e puoi provare a giocare con il programma.

120
00:09:25,540 --> 00:09:26,480
Quindi questo è tutto.

121
00:09:26,590 --> 00:09:27,330
Grazie.

122
00:09:27,410 --> 00:09:28,280
Sono felice di programmare.
