Esistono macchine virtuali Java che possono salvare il loro stato in un file e ricaricare lo stato in questione?

Esistono macchine virtuali Java che possono salvare il loro stato in un file e ricaricare lo stato in questione?

Se sì, quali?

Un’altra opzione, che può o non può essere rilevante nel tuo caso, è quella di eseguire la JVM (qualsiasi JVM) all’interno di una macchina virtuale. La maggior parte delle macchine virtuali offre la possibilità di memorizzare e riprendere lo stato, quindi dovresti essere in grado di riavviare il PC, accendere la VM quando viene ripristinata e fare in modo che il processo Java riprenda da dove si trovava.

Io uso VMWare Player per testare su IE al lavoro, e questo funziona come notato sopra quando chiudo e successivamente riaprilo. In genere non lo faccio quando le app fanno qualcosa di importante nella VM, ma finché non accedono a risorse esterne (ad esempio socket di rete), mi aspetto che funzioni come se la VM non fosse mai chiusa .

È necessario serializzare gli oggetti specifici del dominio pertinenti che possono essere de-serializzati da un altro run-time JVM.

Non sono a conoscenza di strumenti che persistono su un’intera JVM. Il più vicino che ho potuto fare è stato creare un core dump da un processo JVM in esecuzione usando gcore , quindi usando jsadebugd , jmap o jstack per eseguirne il debug.

Per esempio:

$ jps # get JVM process ID XXX $ gcore -o core XXX $ jsadebugd $JAVA_HOME/bin/java core.XXX 

AGGIORNARE

Non penso che troverai una soluzione che è ancora portatile tra le architetture.

Vale la pena notare che molti oggetti non possono essere serializzati in quanto hanno uno stato al di fuori del contesto java. es. socket, thread, file aperti, connessioni database. Per questo motivo, è difficile salvare lo stato di un’applicazione utile in modo generico.

Non sono a conoscenza di JVM che può memorizzare lo stato. A seconda delle tue esigenze, puoi prendere in considerazione l’utilizzo di Terracotta. Terracotta è essenzialmente in grado di condividere lo stato dell’heap tra le JVM e di archiviare questo stato su disco.

Questo può essere utilizzato per le applicazioni cluster e / o rendere persistente lo stato heapstate. In effetti, puoi usarlo per avviare la JVM e riprendere da dove eri rimasto. Per maggiori informazioni consultare: http://www.infoq.com/articles/open-terracotta-intro

Spero che questo ti aiuti.

Le continuazioni sono probabilmente quelle che stai cercando:

[…] continuazioni di prima class, che sono costrutti che danno a un linguaggio di programmazione la possibilità di salvare lo stato di esecuzione in qualsiasi punto e di ritornare a quel punto in un momento successivo nel programma.

Ci sono almeno due librerie di continuazione per Java: continuazioni RIFE e javaflow . So che javaflow consente almeno la serializzazione dello stato su disco:

Una Continuation può essere serializzata se tutti gli oggetti catturati sono anche serializzabili. In altre parole, tutte le variabili locali (compresi tutti this oggetti) devono essere contrassegnate come Serializable . In questo esempio, è necessario contrassegnare la class MyRunnable come serializzabile. Una continuazione serializzata può essere inviata a un’altra macchina o utilizzata in seguito. – Esercitazione su Javaflow

Ho lavorato su un progetto Java integrato che ha utilizzato questo approccio per avviarsi rapidamente. La JVM proveniva da Wind River, in esecuzione su VxWorks.

Sun ha svolto alcune ricerche sulla “persistenza ortogonale”, che fornisce “persistenza per il modello computazionale completo definito dalla specifica del linguaggio Java”:

http://research.sun.com/forest/COM.Sun.Labs.Forest.doc.opjspec.abs.html

PJama è un’implementazione prototipo:

http://research.sun.com/forest/opj.main.html

Per quanto ne so, non c’è nulla per acquisire lo stato JVM e ripristinarlo, ma le persone stanno cercando di serializzare / deserializzare la class Thread per ottenere qualcosa di simile. La cosa più vicina a un’implementazione funzionante che ho trovato era quella dei freni , ma potresti trovare di più quando cerchi “serializzazione dei thread”.

Immagino che tu voglia essere in grado di riprendere da dove è stata memorizzata l’istantanea, come se nulla fosse accaduto successivamente.

Mi chiedo quanti componenti e librerie del framework si rompono. All’improvviso, stai ripristinando uno stato JVM dallo storage; nel frattempo, l’orologio è misteriosamente saltato in avanti di 23 ore, le connessioni di rete non sono più valide, gli oggetti della GUI non hanno più maniglie O / S sottostanti … Direi che questo non è banale, ed è imansible nel caso generale senza modificare ampiamente il framework.

Se riesci a farla franca semplicemente memorizzando lo stato dei tuoi oggetti in memoria, qualcosa come Prevaylor potrebbe funzionare per te. Utilizza una combinazione di modifiche giornaliere agli oggetti di business con un’istantanea serializzata per registrare lo stato dei tuoi oggetti, che puoi quindi ricaricare in un secondo momento.

Tuttavia, non memorizza lo stato JVM completo (stack di chiamate, stato GC ecc.). Se hai davvero bisogno di quel livello di dettaglio, potrebbe essere necessaria una JVM specializzata.

La risposta in questo momento è no , non ci sono JVM che possono “hibernate” come il tuo sistema operativo può o come può VMWare et al.

Potresti arrivare a metà strada, a seconda della complessità della tua app, semplicemente serializzando lo stato quando il programma si chiude e serializzandolo di nuovo, ma ciò non farà cose come pause che eseguono alcune logiche di business quando chiudi e poi continui quando lo apri di nuovo.