Pianificazione di alcune attività a uso intensivo della CPU

Ho bisogno di pianificare un piccolo numero di attività che richiedono molta CPU da eseguire ogni tanto, leggendo da dati condivisi e scrivendo su buffer dedicati. Non voglio necessariamente eseguire il mio programma, ma non sono sicuro che librerie come Quartz siano appropriate per questo piccolo di scala. Sto usando Java 8 in un ambiente server, ma con nodi isolati e non importa se alcune iterazioni vengono perse ogni tanto.

Dettagli problema:

Ho 5 buffer di dati di dati binari da elaborare. Prima di elaborare ciascun buffer, alloco una destinazione vuota e la funzione scrive su quella destinazione. Ogni buffer deve essere elaborato su un programma diverso con una funzione diversa, sebbene tutte le funzioni possano gestire un'iterazione mancante e calcolare il doppio al prossimo passaggio.

Il primo buffer è ~ 30mb e richiede ~ 200ms per essere elaborato e deve essere elaborato ogni 500ms. Il resto è di circa 6 Mb ciascuna e richiede circa 50 ms per essere elaborato e deve essere elaborato ogni 1000 ms.

Le funzioni di elaborazione devono solo scrivere nel buffer di destinazione e sono prive di stato, ma possono leggere qualsiasi buffer esistente. L'intero processo avrà almeno una propria discussione e potrebbe avere più thread. Niente di tutto questo è critico, non sarà cluster e verrà mantenuto quasi esclusivamente in memoria.

Esempio:

Un'implementazione abbastanza stupida potrebbe essere:

for (layer in parent.layers) {
    new thread(() => {
        while (true) {
            buffer = new int[layer.data.length]
            process(layer.data, buffer, parent)    // remember, this can access other layers
            layer.data = buffer
            sleep(layer.increment)
        }
    }
}    

L'esecuzione di ogni livello sul proprio thread rende l'elaborazione abbastanza semplice, purché nulla nel mezzo sia bloccato. Afferrando ogni livello a cui la funzione di elaborazione si preoccupa quando inizia un'iterazione e rilasciandoli alla fine dovrebbe funzionare, poiché sono di sola lettura e non sono preoccupato per un altro thread che sostituisce il riferimento.

Domanda:

1. Ci sono problemi con Timer per questo tipo di lavoro? Offrono un modo per scartare o attendere l'iterazione precedente?
2. Il quarzo è una scelta praticabile o semplicemente assurda?
3. Può bastare qualcosa di semplice come System.nanoTime con questa precisione?