Discussion :

[®om]

Salut,

Pour créer un Executor facilement, j'utilise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Executors.newSingleThreadPoolExecutor();

par exemple.

Le problème, c'est que les threads sont non-démons.

N'y-a-t-il pas quelque part un truc pour créer des thread démons par défaut, déjà implémenté dans l'API ?

Car pour l'instant je me suis fait une classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * Complément de la classe {@code java.util.concurrent.Executors}, permettant de créer un pool de threads démons.
 * 
 * @author rom
 */
public final class DaemonExecutors {
 
	/** ThreadFactory à utiliser pour créer des threads démons. */
	private static final ThreadFactory threadFactory = new ThreadFactory() {
 
		public Thread newThread(Runnable r) {
			/* On demande au ThreadFactory par défaut de créer un Thread. */
			Thread thread = Executors.defaultThreadFactory().newThread(r);
			/* On configure ce thread en mode démon. */
			thread.setDaemon(true);
			/* On le retourne. */
			return thread;
		}
	};
 
	/** Interdiction d'instancier. */
	private DaemonExecutors() {}
 
	/**
         * Retourne un {@code ThreadFactory} de threads démons.
         * 
         * @return {@code ThreadFactory} de threads démons.
         */
	public static ThreadFactory defaultDaemonThreadFactory() {
		return threadFactory;
	}
 
	/**
         * Retourne un exécuteurde threads démons.
         * 
         * @return Exécuteur de threads démons.
         */
	public static ExecutorService newSingleDaemonThreadExecutor() {
		return Executors.newSingleThreadExecutor(defaultDaemonThreadFactory());
	}
 
	/**
         * Retourne un exécuteur planifié de threads démons.
         * 
         * @return Exécuteur planifié de threads démons.
         */
	public static ScheduledExecutorService newSingleDaemonThreadScheduledExecutor() {
		return Executors.newSingleThreadScheduledExecutor(defaultDaemonThreadFactory());
	}
 
}

qui permet de créer des threads démons facilement, mais je trouve cela étonnant que ça ne soit pas dans l'API standard...

Pourriez-vous confirmer ou infirmer svp?

[adiGuba]

Salut,

N'y-a-t-il pas quelque part un truc pour créer des thread démons par défaut, déjà implémenté dans l'API ?

Non pas à ma connaissance. La solution est bien de coder son propre ThreadFactory...



Par contre attention à ton implémentation, car Executors.defaultThreadFactory() renvoi une nouvelle instance à chaque appel. Je ferais plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * Complément de la classe {@code java.util.concurrent.Executors}, permettant de créer un pool de threads démons.
 * 
 * @author <a href="mailto:rom1v@yahoo.fr">Romain Vimont</a> (®om)
 */
public final class DaemonExecutors {
 
	/** ThreadFactory à utiliser pour créer des threads démons. */
	private static final ThreadFactory threadFactory = new ThreadFactory() {
		private final ThreadFactory defaultFactory = Executors.defaultThreadFactory();
 
		public Thread newThread(Runnable r) {
			/* On demande au ThreadFactory par défaut de créer un Thread. */
			Thread thread = defaultFactory.newThread(r);
			/* On configure ce thread en mode démon. */
			thread.setDaemon(true);
			/* On le retourne. */
			return thread;
		}
	};
...

Ou alors carrément une classe interne et une nouvelle instance à chaque appel comme defaultThreadFactory()...


a++

[®om]

Ah ouais, bien vu

(par contre on ne peut pas mettre d'attributs dans une classe anonymes)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/**
 * Complément de la classe {@code java.util.concurrent.Executors}, permettant de créer un pool de threads démons.
 * 
 * @author rom
 */
public final class DaemonExecutors {
 
	/**
         * ThreadFactory à utiliser pour créer des threads démons.
         */
	private static class DefaultDaemonThreadFactory implements ThreadFactory {
 
		/** Fabrique de threads par défaut. */
		private final ThreadFactory defaultThreadFactory = Executors.defaultThreadFactory();
 
		@Override
		public Thread newThread(Runnable r) {
			/* On demande à la fabrique de threads par défaut de créer un Thread. */
			Thread thread = defaultThreadFactory.newThread(r);
			/* On configure ce thread en mode démon. */
			thread.setDaemon(true);
			/* On le retourne. */
			return thread;
		}
	};
 
	/** Interdiction d'instancier. */
	private DaemonExecutors() {}
 
	/**
         * Retourne un {@code ThreadFactory} de threads démons.
         * 
         * @return {@code ThreadFactory} de threads démons.
         */
	public static ThreadFactory defaultDaemonThreadFactory() {
		return new DefaultDaemonThreadFactory();
	}
 
	/**
         * Retourne un exécuteurde threads démons.
         * 
         * @return Exécuteur de threads démons.
         */
	public static ExecutorService newSingleDaemonThreadExecutor() {
		return Executors.newSingleThreadExecutor(defaultDaemonThreadFactory());
	}
 
	/**
         * Retourne un exécuteur planifié de threads démons.
         * 
         * @return Exécuteur planifié de threads démons.
         */
	public static ScheduledExecutorService newSingleDaemonThreadScheduledExecutor() {
		return Executors.newSingleThreadScheduledExecutor(defaultDaemonThreadFactory());
	}
 
}

C'est bizarre qu'ils donnent une nouvelle factory à chaque fois...

Et c'est bizarre qu'ils ne fournissent pas une factory de threads démons par défaut, car les timers souvent c'est pour être démon.

[adiGuba]

(par contre on ne peut pas mettre d'attributs dans une classe anonymes)

Oui on peut (un attribut d'instance, pas un attribut static )

C'est bizarre qu'ils donnent une nouvelle factory à chaque fois...

En effet le nom de la méthode n'est pas très clair. Perso j'aurais plutôt utilisé createDefaultThreadFactory() ou newDefaultThreadFactory()...

Et c'est bizarre qu'ils ne fournissent pas une factory de threads démons par défaut, car les timers souvent c'est pour être démon.

Oui on voudrait toujours que l'API propose de tout... ce n'est malheureusement que rarement le cas

a++

[®om]

Oui on peut (un attribut d'instance, pas un attribut static )

Ah ouais, j'étais persuadé du contraire... Effectivement ça marche...
C'est juste le constructeur alors...