1
00:00:02,190 --> 00:00:05,850
Ciao, ci sono da lunedì a lunedì Lou e bentornato.

2
00:00:05,850 --> 00:00:13,170
Non otteniamo la garbage collection quando cancelliamo un oggetto usando la parola Nuki GBM determina la quantità di

3
00:00:13,170 --> 00:00:18,530
memoria necessaria per archiviare quell'oggetto sotto la ricerca di tanta quantità di memoria.

4
00:00:19,050 --> 00:00:24,340
Ma man mano che sempre più oggetti vengono creati, ciò comporterebbe anche l'individuazione di più memoria.

5
00:00:24,440 --> 00:00:30,350
Se continuiamo a creare oggetti in questo modo alla fine potremmo esaurire la memoria e

6
00:00:30,450 --> 00:00:38,720
otterremo errori come tutta la memoria o quindi è necessario liberare o recuperare memoria quando gli oggetti non sono più necessari.

7
00:00:38,720 --> 00:00:44,420
Questo è un aspetto molto importante della gestione della memoria e Djala è stick e si

8
00:00:44,510 --> 00:00:46,440
spegne automaticamente dal garbage collector.

9
00:00:46,520 --> 00:00:52,160
Dal momento che stiamo parlando di oggetti che sappiamo essere archiviati su heap, il nostro focus

10
00:00:52,280 --> 00:00:59,660
per le prossime lezioni sarà sulla memoria heap su come Garbage Collector Manolis in quest'area garbage collection è uno dei più

11
00:00:59,660 --> 00:01:02,320
importanti vantaggi di Jalla su più grande.

12
00:01:02,320 --> 00:01:09,070
Osservando i diversi algoritmi di garbage collection che possono essere utilizzati alla fine possiamo anche vedere come

13
00:01:09,070 --> 00:01:11,900
possiamo accumulare le dimensioni della memoria.

14
00:01:12,140 --> 00:01:17,300
Quindi saranno interessanti le lettere di Saratov che ci servono per capire

15
00:01:17,300 --> 00:01:25,940
bene come funziona la garbage collection in linguaggi come il programmatore C o C ++ deve guardare esplicitamente alla memoria

16
00:01:25,940 --> 00:01:27,610
quando crea oggetti.

17
00:01:27,740 --> 00:01:33,980
E allo stesso modo quando quegli oggetti non sono più necessari devono liberare esplicitamente lo spazio

18
00:01:34,000 --> 00:01:35,810
occupato da quegli oggetti.

19
00:01:35,810 --> 00:01:39,560
Quindi i programmatori stanno manipolando esplicitamente la memoria.

20
00:01:39,640 --> 00:01:41,400
Questo sarebbe sicuramente di grande aiuto.

21
00:01:41,490 --> 00:01:48,960
Applicazioni efficienti ma in progetti di grandi dimensioni se tale manipolazione della memoria non viene eseguita correttamente, potrebbe causare problemi gravi

22
00:01:48,960 --> 00:01:55,740
come il crash del programma o dei programmi che funzionano in Karachi quando la recente azione Manipal della memoria

23
00:01:55,740 --> 00:01:57,560
non viene eseguita correttamente.

24
00:01:57,660 --> 00:02:01,050
Significa che la memoria è corrotta in qualche modo.

25
00:02:01,110 --> 00:02:08,950
Sembra che quasi il 10% dei crash dell'applicazione sui sistemi Windows sia dovuto a un danneggiamento della memoria.

26
00:02:08,970 --> 00:02:11,450
Diamo un'occhiata ad un paio di aree in cui la memoria può essere raggiunta.

27
00:02:11,450 --> 00:02:13,740
Dai un'occhiata a due di loro.

28
00:02:13,860 --> 00:02:21,650
Anche se ci possono essere più settimane di merda in memoria l'elaborazione delle perdite di memoria perdite di memoria si verificano

29
00:02:21,800 --> 00:02:24,900
quando vengono notificati gli oggetti non utilizzati.

30
00:02:24,910 --> 00:02:31,620
Ad esempio potresti avere un riferimento a un oggetto che punta a un oggetto e tale riferimento viene successivamente assegnato a

31
00:02:31,630 --> 00:02:32,680
un nuovo oggetto.

32
00:02:33,010 --> 00:02:39,390
Quindi tutto ciò non ha un riferimento attivo e possiamo riferirci ad esso come un debito o un oggetto abbandonato.

33
00:02:39,850 --> 00:02:43,540
Nessuno degli spazi occupati da questo oggetto abbandonato non è libero.

34
00:02:43,720 --> 00:02:50,660
Allora quella sarebbe una perdita di memoria sotto tali perdite di memoria che avvengono regolarmente, quindi sappiamo che alla fine

35
00:02:50,690 --> 00:02:52,080
potremmo esaurire la memoria.

36
00:02:52,140 --> 00:02:54,900
Un altro programma dovrebbe semplicemente smettere di cercare.

37
00:02:55,220 --> 00:03:01,160
Se il nostro programma funziona solo per un breve periodo di tempo con poche perdite di memoria, allora potremmo andare bene e forse non sapremo

38
00:03:01,160 --> 00:03:03,090
nemmeno che c'è una perdita di memoria.

39
00:03:03,650 --> 00:03:09,160
Ma per i programmi a lungo termine come le applicazioni web potrebbe rivelarsi un problema molto serio.

40
00:03:10,800 --> 00:03:16,920
Un altro tipo di errore è il riferimento ciondolante che è fondamentalmente un riferimento a un'area fuori dalla

41
00:03:16,920 --> 00:03:19,200
memoria che è già stata recuperata.

42
00:03:19,320 --> 00:03:24,360
Ad esempio consideriamo due componenti separati che condividono lo stesso oggetto.

43
00:03:25,130 --> 00:03:30,750
Ora uno dei componenti viene fatto usando quell'oggetto, quindi può liberare la memoria occupata da quell'oggetto

44
00:03:30,750 --> 00:03:35,360
e quella facilità di memoria potrebbe dargli un'occhiata con un nuovo oggetto.

45
00:03:36,350 --> 00:03:41,600
Ma il secondo componente farebbe comunque riferimento alla stessa posizione di memoria e allo zoom che l'oggetto è

46
00:03:41,660 --> 00:03:42,470
ancora lì.

47
00:03:43,300 --> 00:03:49,180
Poiché non si tratta di un oggetto diverso che occupa molto spazio, il secondo componente si

48
00:03:49,240 --> 00:03:51,330
comporterà sicuramente in modo imprevedibile.

49
00:03:52,140 --> 00:03:54,060
Quindi questo è un riferimento ciondolante.

50
00:03:55,820 --> 00:04:01,150
Un modo per controllare meno la corruzione della memoria nel peggiore dei casi è limitare i programmatori dalla manipolazione

51
00:04:01,990 --> 00:04:08,280
della memoria e in luglio attraverso la gestione della memoria automatica o implicita, che è uno dei suoi principali vantaggi rispetto a

52
00:04:08,280 --> 00:04:10,190
un linguaggio come il C ++.

53
00:04:10,460 --> 00:04:17,470
Angela lo fa attraverso un processo chiamato garbage collection che viene eseguito da un componente di Gibeon.

54
00:04:17,560 --> 00:04:24,170
Garbage collector al posto dei programmatori Garbage Collector o GC in stato di shock.

55
00:04:24,260 --> 00:04:28,550
Fondamentalmente per recuperare la memoria occupata da oggetti morti.

56
00:04:28,550 --> 00:04:34,640
In questo modo si garantisce che non ci siano perdite di memoria in modo che ci

57
00:04:34,700 --> 00:04:42,510
siano oggetti che rappresentano fondamentalmente rifiuti che devono essere recuperati, ma bisogna anche assicurarsi che un oggetto morto sia davvero

58
00:04:42,510 --> 00:04:48,990
un oggetto morto che deve essere sicuro al 100 percento che non ci sono riferimenti attivi a

59
00:04:48,990 --> 00:04:50,200
quell'oggetto particolare.

60
00:04:50,220 --> 00:04:53,060
Altrimenti potremmo finire con una situazione di riferimento ciondolante.

61
00:04:53,820 --> 00:05:00,310
Quindi GC garantisce che non ci siano riferimenti ciondolanti o in altre parole garantisce che un oggetto

62
00:05:00,460 --> 00:05:03,870
con almeno un riferimento non stia mai solleticando.

63
00:05:04,060 --> 00:05:09,740
Quindi Garbage Collector impedisce automaticamente entrambi i tipi di errori che possono ridurre la memoria.

64
00:05:09,790 --> 00:05:12,450
Quindi il programmatore non ha a che fare con cose del genere.

65
00:05:12,560 --> 00:05:15,560
Migliora la sua produttività.

66
00:05:15,770 --> 00:05:20,530
Quindi i programmatori Java creano oggetti con altri lavori di Nuki su GBM.

67
00:05:20,540 --> 00:05:22,210
Guarda la memoria necessaria.

68
00:05:22,490 --> 00:05:30,280
Ma il recupero di oggetti verrà eseguito dal garbage collector semplicemente non facendo riferimento a un oggetto più qualificato come

69
00:05:30,340 --> 00:05:35,960
tale oggetto come oggetto abbandonato che lo rende idoneo per la garbage collection.

70
00:05:35,960 --> 00:05:42,240
Naturalmente stiamo riprendendo che l'oggetto non ha altri riferimenti attivi per esaminare alcuni modi in cui

71
00:05:42,240 --> 00:05:44,060
gli oggetti vengono abbandonati.

72
00:05:45,480 --> 00:05:50,550
Un oggetto può essere considerato abbandonato se anche qui va oltre lo scopo non importa.

73
00:05:50,570 --> 00:05:51,660
Buona liberazione.

74
00:05:51,680 --> 00:05:56,810
L'oggetto libro è considerato abbandonato e sarà idoneo per la garbage collection.

75
00:05:56,940 --> 00:06:01,190
Questo sarebbe ancora in attesa finché GC non lo riacquisterà.

76
00:06:03,050 --> 00:06:10,790
Un oggetto sarebbe abbandonato attraverso il suo riferimento è assegnato qualche altro oggetto o è assegnato

77
00:06:10,790 --> 00:06:12,250
un valore nullo.

78
00:06:12,420 --> 00:06:16,630
Quindi hai tre modi in cui un oggetto diventa idoneo per la garbage collection.

79
00:06:17,700 --> 00:06:21,020
Non è nemmeno un oggetto di classe che è un'istanza disattivata.

80
00:06:21,020 --> 00:06:23,100
I lavori non sono di tipo landlock.

81
00:06:23,140 --> 00:06:29,670
Se non ha riferimenti attivi, sarà anche idoneo per la garbage collection.

82
00:06:29,680 --> 00:06:36,870
Non guardiamo alcune specifiche su GC GC può essere implementato come parte del linguaggio stesso come nel caso

83
00:06:36,870 --> 00:06:37,940
di Java.

84
00:06:38,250 --> 00:06:44,670
Oppure potrebbe essere una libreria aggiuntiva, come nel caso di altre lingue che si

85
00:06:44,670 --> 00:06:47,540
basano sulla gestione manuale della memoria.

86
00:06:47,550 --> 00:06:54,630
Inoltre viene eseguito da cresciuto nel thread a bassa priorità, quindi fa tutto ciò che è vivo e entra in

87
00:06:54,780 --> 00:07:01,820
azione ogni volta che c'è carenza di memoria e non c'è alcuna garanzia che GC funzioni con programmatori che

88
00:07:01,820 --> 00:07:04,420
hanno un controllo limitato su Brenny.

89
00:07:04,640 --> 00:07:09,730
Di solito funziona quando c'è una memoria limitata ma il tempo esatto è imprevedibile.

90
00:07:11,570 --> 00:07:17,580
Un altro può dare un suggerimento alla JVM che potrebbe eseguire GC con uno di questi approcci.

91
00:07:17,580 --> 00:07:24,960
Uno è richiamando il metodo DC e la classe di sistema o invocando il metodo DC B o che ottiene il metodo

92
00:07:25,250 --> 00:07:26,890
runtime nella classe runtime.

93
00:07:26,930 --> 00:07:32,670
Questo è il System Runtime di Strawman che appartiene al pacchetto Java Rockline e il bene di entrambi questi approcci

94
00:07:32,670 --> 00:07:33,850
è lo stesso.

95
00:07:33,950 --> 00:07:37,790
È come se il sistema o il GC fornissero un modo più conveniente per farlo.

96
00:07:38,670 --> 00:07:42,310
Ma questo è solo un suggerimento su Gibeah può ignorare il segnale.

97
00:07:42,930 --> 00:07:50,210
Quindi non dovresti mai fare affidamento su questo approccio manuale per invocare il GC e dovresti amare JVM offrirlo.

98
00:07:50,410 --> 00:07:57,460
Fondamentalmente, GC è un compito piuttosto complesso e ogni volta che viene eseguito ci vuole tempo e le

99
00:07:58,450 --> 00:08:05,320
risorse su ciascuna di esse sono indicate come un ciclo GC e possono causare pause nell'applicazione e queste

100
00:08:05,320 --> 00:08:10,450
pause possono essere di durata variabile a seconda dell'algoritmo GC in uso.

101
00:08:10,610 --> 00:08:17,160
Se l'applicazione arriva a una pausa completa, viene chiamata stub, il bus consente a tutti di vedere

102
00:08:17,160 --> 00:08:23,960
una tecnica chiamata raccolta generazionale che viene utilizzata da GC per ridurre Boston. Questa è una breve

103
00:08:23,960 --> 00:08:25,960
introduzione alla garbage collection.

104
00:08:25,970 --> 00:08:29,100
In pratica garantisce che la memoria non sia corrotta.

105
00:08:29,790 --> 00:08:36,280
Solleva il programmatore dalla manipolazione esplicita della memoria in modo da migliorare la produttività del programmatore.

106
00:08:36,780 --> 00:08:42,990
Quindi la gestione automatica della memoria è un enorme vantaggio che deriva da Majola e rende la programmazione in

107
00:08:43,080 --> 00:08:44,860
Java più semplice e sicura.

108
00:08:45,270 --> 00:08:45,630
Grazie.
