Interface graphique Java et plusieurs instances de la classe SwingWorker

Question

Je crée une interface graphique utilisant Java (qui ne l'est pas?). Je sais que la classe Swing Worker permet le calcul en arrière-plan pour empêcher l'interface graphique de se bloquer, mais je me demandais s'il y aurait trop de bonnes choses ici ...

Par exemple, s'il y avait trop d'instances de ces threads d'arrière-plan en cours d'exécution, cela affecterait-il les performances du programme en fonction de l'ordinateur? Une question simple mais importante. J'apprécierais grandement toute contribution. Merci pour votre temps.

Answer 1

Oui, plus vous effectuez de traitement, plus les performances de l'ordinateur seront affectées. Après tout, les ressources de traitement sont une ressource limitée. Cela dit, de nombreux ordinateurs modernes ont multiple cores, ce qui signifie qu'une application monothread ne sera probablement pas en mesure de tirer pleinement parti des ressources du processeur.

En général, quelques threads en cours d'exécution ne vont pas être un gros problème. Cependant, une fois qu'il y a des centaines ou des milliers de threads, les performances peuvent se dégrader, car le temps nécessaire pour faire un context switch entre les threads peut commencer à occuper une plus grande partie des ressources de traitement disponibles.

Answer 2

Si vous plonger dans le code SwingWorker vous verrez la constante suivante définie:

/** 
* number of worker threads. 
*/ 
private static final int MAX_WORKER_THREADS = 10; 

Par conséquent, le nombre de threads d'arrière-plan ne peut jamais dépasser cette valeur quel que soit le nombre d'entre vous de SwingWorker réellement créer . Une façon de faire varier le modèle de thread de fond serait de brancher votre propre ExecutorService dans le AppContext associé à la classe SwingWorker. Cependant, ceci est légèrement douteux étant donné que AppContext appartient à sun.awt et ne fait donc pas partie de l'API JDK officielle.

// Create single thread executor to force all background tasks to run on the same thread. 
ExecutorService execService = Executors.newSingleThreadExecutor(); 

// Retrieve the AppContext. *CAUTION*: This is part of the sun.awt package. 
AppContext ctxt = AppContext.getAppContext(); 

// Verify that nothing is already associated with SwingWorker.class within the context. 
Object obj = ctxt.get(SwingWorker.class); 

if (obj != null) { 
    throw new IllegalStateException("Object already associated with SwingWorker: " + obj); 
} 

// Install ExecutorService. Will be retrieved by the SwingWorker when execute() is called. 
ctxt.put(SwingWorker.class, ctxt); 

Answer 3

Cela dépend du nombre de cœurs que vous avez. Par exemple, si vous avez deux cœurs, vous pouvez générer en toute sécurité une tâche en arrière-plan car vous générez deux threads, un pour l'interface utilisateur et un pour la tâche, qui se divise bien entre les deux cœurs. Toutefois, la tâche de l'interface utilisateur est souvent inactive (en attendant que l'utilisateur fasse quelque chose). Ainsi, dans 99% des cas, sur une machine à deux cœurs, vous pouvez générer deux threads de travail (en plus du thread UI standard qui est toujours présent)