Quel est le comportement correct du processus d'arrière-plan pour une application Java non graphique?

Question

Quelle est la bonne manière pour une application de ligne de commande Java de travailler en arrière-plan sans accumuler les ressources? Devrait-il utiliser sleep () dans la boucle ou existe-t-il un moyen plus élégant / efficace?

Answer 1

Quelques heuristiques:

• N'essayez pas de prendre des décisions de planification dans votre application. Le planificateur du système d'exploitation est bien meilleur que le vôtre. Laissez-le faire son travail.
• Ne sondez pas si vous n'y êtes pas obligé Par exemple, au lieu de dormir n secondes, puis de vous lever pour vérifier une socket non bloquée, bloquez-la. Cette deuxième stratégie fonctionne mieux avec le planificateur du système d'exploitation.
• N'utilisez pas un tas énorme si vous n'y êtes pas obligé et essayez de ne pas allouer d'énormes morceaux de mémoire en même temps. Une application complexe a tendance à avoir un impact négatif sur les performances du système.
• Utilisez des E / S en mémoire tampon. Toujours. Si vous pensez avoir besoin d'E / S non tamponnées, assurez-vous que vous avez raison. (Vous avez probablement tort.)
• Ne créez pas beaucoup de threads. Les fils sont étonnamment chers; au-delà d'un certain point, davantage de threads réduiront le profil de performance de votre application. Si vous avez beaucoup de travail à faire simultanément, apprenez et utilisez java.util.concurrent .

Bien sûr, il ne s'agit que d'une liste de départ ...

Answer 2

Je n'utiliserais sleep () que s'il n'y a pas de travail à faire. Par exemple, si vous interrogez une file de tâches périodiquement et qu’il n’y a rien, mettez-vous en veille un moment, puis vérifiez à nouveau, etc.

Si vous essayez simplement de vous assurer que le processeur n’est pas trop encombré mais que vous faites toujours du vrai travail, vous pouvez appeler Thread.yield () régulièrement. Cela abandonnera le contrôle de la CPU et laissera les autres threads s'exécuter, mais cela ne vous empêchera pas de dormir. Si d’autres processus n’ont pas besoin de la CPU, vous reprendrez le contrôle et continuerez à faire votre travail.

Vous pouvez également définir votre thread sur une priorité basse: myThread.setPriority (Thread.MIN_PRIORITY);

Comme l'a dit Ismaël, ne faites pas cela dans votre fil principal. Créer un " thread de travail " au lieu. Ainsi, votre interface utilisateur (GUI ou CLI) sera toujours réactive.

Answer 3

Il y a plusieurs façons. J'utiliserais ExecutorService ... par exemple:

ExecutorService service = Executors.newCachedThreadPool();

Callable<Result> task = new Callable<Result>() {
    public Result call() throws Exception {
        // code which will be run on background thread
    }
};

Future<Result> future = service.submit(task);

// Next line wait until background task is complete
// without killing CPU. Of course, you can do something
// different here and check your 'future' later.
//
// Note also that future.get() may throw various exceptions too,
// you'll need to handle them properly

Result resultFromBackgroundThread = future.get();

Il s'agit du code Java 5, ExecutorService, Callable, Future et similaires se trouvent dans le package java.util.concurrent .

Answer 4

Pour commencer, assurez-vous que seules ces ressources sont utilisées et aucun autre objet (afin qu'elles ne soient pas nettoyées).

Placer sleep () dans une seule application de threading ne fera qu’arrêter le thread actuel. Si vous essayez d'exécuter des données traitées en arrière-plan alors que des informations doivent encore être présentées à l'utilisateur, il est préférable de placer le processus d'arrière-plan dans un fil séparé.