Domanda

La memoria heap è garbage collection in Java.

E 'la spazzatura pila raccolti così?

Come è memoria impilare recuperato?

Nessuna soluzione corretta

Altri suggerimenti

La memoria alla pila contiene metodo parametri e le variabili locali (per la precisione: i riferimenti per gli oggetti e si variabili per i tipi primitivi). Che verranno rimossi automaticamente se si lascia il metodo. Se le variabili sono riferimenti a oggetti () gli oggetti si trovano sul mucchio e gestito dal garbage collector.

Quindi, la pila, non è spazzatura raccolti nello stesso modo come il mucchio, ma stack è una forma di memoria-gestione automatica nel suo pieno (che è anteriore garbage collection).

Un risposta più dettagliata è data da Thomas Pornin , guardare in quella per maggiori dettagli.

La pila non è garbage collection in Java.

Lo stack assegnato per una determinata chiamata metodo viene liberata quando il metodo ritorna. Dal momento che è una struttura molto semplice LIFO, non c'è bisogno per la raccolta dei rifiuti.

Un luogo in cui la pila e la raccolta dei rifiuti Interact è che i riferimenti nello stack sono radici GC (il che significa che essi sono i riferimenti alla radice da cui raggiungibilità si decide).

Lo stack di potrebbero essere garbage collection. Tuttavia, nella maggior parte delle implementazioni JVM, viene gestita come, anche, un "stack", che per definizione esclude garbage collection.

Ciò che noi chiamiamo lo stack è l'accumulo di contesti metodo di attivazione : per ogni metodo invocato, questa è la struttura concettuale che contiene gli argomenti del metodo, le variabili locali, un puntatore nascosta al contesto per la metodo, e uno slot chiamando per salvare il puntatore all'istruzione. Il contesto di attivazione non è accessibile in quanto tale, dal linguaggio Java stesso. Un contesto diventa inutile quando il metodo termina (con un return oa causa di un eccezione generata). Accade così che quando un metodo A chiama un metodo B, è garantito che quando A riprende il controllo, il contesto B è diventato inutile. Ciò implica che la vita del contesto per B è un sottoinsieme della vita del contesto per A. Pertanto, i contesti di attivazione (per un dato filo) possono essere assegnati con un LIFO ( "Last In, First Out") disciplina. In parole semplici, una pila:. Un nuovo contesto di attivazione è spinto in cima alla pila di contesti, e il contesto sopra saranno i primi da smaltire

In pratica, i contesti di attivazione (chiamati anche stack frame ) sono concatenati, in ordine di impilamento, in un'area dedicata. Tale superficie è ottenuta dal sistema operativo all'avvio del filo, e il sistema operativo ottiene indietro quando il filo termina. La parte superiore della pila è indicato da un puntatore specifico, spesso contenute in un registro CPU (questo dipende dal fatto che la JVM interpreta o compilazione del codice). Il "puntatore a contesto del chiamante" è virtuale; contesto del chiamante è necessariamente trova proprio sotto al fine di stack. Il GC non interviene: l'area per la pila viene creato e recuperato in modo sincrono, dall'attività filo stesso. Questo è anche come funziona in molte lingue come il C , che non hanno un GC a tutti.

Ora nulla impedisce un'implementazione JVM da fare diversamente, per esempio ripartizione contesti di attivazione nel mucchio e averli raccolti dal GC. Questo non è solitamente fatto in Java Virtual Machine dal allocazione dello stack è più veloce. Ma alcuni altri linguaggi hanno bisogno di fare queste cose, in particolare quelli che giocano con continuazioni pur utilizzando un GC (ad esempio Scheme e la sua function call-with-current-continuation), perché tali giochi rompere la regola LIFO spiegato sopra.

La parte pila di memoria funziona come una "pila". So che suona male, ma questo è esattamente come funziona. I dati si aggiunge alla parte superiore, uno sopra l'altro (pushed onto the stack) e viene rimosso automaticamente dalla parte superiore (popped off the stack) come programma viene eseguito. Non è garbage collection - e non ha bisogno di essere dal momento che la memoria venga recuperato automaticamente una volta che i dati vengono estratto dallo stack. E quando dico bonificata non voglio dire che venga de-allocata -. È solo che la posizione nella memoria dello stack in cui verranno memorizzati i dati successivi è diminuita, come dati viene estratto

Naturalmente questo non vuol dire che non c'è bisogno di preoccuparsi affatto di stack. Se si esegue una funzione ricorsiva molte volte finirà per utilizzare tutto lo spazio di stack. Lo stesso se si chiama molte funzioni, soprattutto se hanno molti parametri e / o variabili locali.

Ma la linea di fondo è che la memoria dello stack è usato e recuperato come funzioni entrano ed escono portata - automaticamente. Così, alla fine dell'esecuzione del programma di tutta la memoria dello stack sarebbe libero e poi rilasciato di nuovo al sistema operativo.

Se si fa riferimento alla memoria utilizzata in pila, non è garbage collection.
La macchina virtuale Java utilizza istruzioni bytecode esplicite per riservare e rilasciare memoria sullo stack, queste istruzioni vengono generati dal compilatore e gestire il ciclo di vita dei primitivi come int, boolean, doppie e oggetti riferimenti nello stack.
Ci sono stati piani per implementare una cosiddetta ottimizzazione chiamata coda, che eliminerebbe alcune voci dallo stack una volta che si sa che non sono più utilizzati sono, ma non so alcuna JVM che supporta già questo.
Quindi, non v'è alcuna raccolta dei rifiuti per lo stack stesso, solo le istruzioni push e pop compilatore generato per gestire l'utilizzo della memoria.

La pila stessa è parte di un thread. Lo stack viene allocata quando viene creato l'oggetto filo e la spazzatura raccolto dopo il filo terminato e l'oggetto filo non viene fatto riferimento.

Tutti gli oggetti in Java sono allocati sul mucchio. (Almeno per quanto riguarda le specifiche va, l'effettiva implementazione li può allocare in pila se trasparente comportano come se fossero sul mucchio.)

Esattamente quello che è da collezione è un po 'sottile. Se l'unico riferimento a un oggetto è in un unico stack frame, e si può dimostrare che riferimento non sarà utilizzato nuovamente, l'oggetto può essere raccolto. Se l'oggetto viene utilizzato solo per leggere un campo, quindi quel campo di lettura può essere ottimizzata in avanti e l'oggetto raccolto prima di quanto ci si potrebbe aspettare.

Questo di solito non importa se non si utilizza finalisers (o presumibilmente References). In questo caso si dovrebbe fare attenzione e utilizzare i blocchi / volatile per far rispettare un rapporto happens-before.

Quando discussioni fermano, quindi tipicamente l'intera pila viene deallocato.

Tutto situata sulla pila è trattata come radici globali di spazzino. Quindi, sì, si può sicuramente dire che stack viene "garbage collection".

Nessuno, i dati sono spinto e schioccato dallo stack quando si dispone di variabili interne nei metodi, durante le chiamate di metodo, ecc Non è necessario preoccuparsi di questo.

No. Lo stack non è garbage collection in Java. Ogni thread ha il proprio stack e contiene:

  1. valori specifici di metodo (che sono di breve durata) e
  2. I riferimenti agli oggetti creati sul mucchio, e vengono indicato dal metodo

Questi valori sono spinti come stack frame allo stack per ogni chiamata di metodo. Poiché la pila segue ordine 'last-in first-out', alla fine di ogni chiamata di metodo, ogni stack frame contenente tutti i dati specifici del metodo e dei riferimenti agli oggetti, se presente, viene estratto fuori.

Quindi, i dati nella pila vengono puliti automaticamente una volta che il metodo / programma passa nell'ambito.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top