Créer un timer qui limite le temps de réponse

Version imprimable

Bonjour,

Je souhaite créer un timer limitant le temps de réponse dans un code destiné à interroger l'utilisateur.
Après un certain temps on passe à la question suivante.
Je n'y parviens pas... Help

J'ai bien trouvé ce code mais je n'arrive pas à l'insérer dans ma classe "examiner"

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Timer;
import java.util.TimerTask;
 
 
public class TimerPerso {
 
 
    public static void main(String[] args) {
 
 
        long temps = 2000;                      // délai avant de répéter la tache : 2000 = 2  seconde
        long startTime = 0;                    // délai avant la mise en route (0 demarre immediatement)
        Timer timer = new Timer();             // création du timer
        TimerTask tache = new TimerTask() {     // création et spécification de la tache à effectuer
            @Override
                public void run() {
                    System.out.println("salut");    // ici se qui doit être effectué
                }
        };
        timer.scheduleAtFixedRate(tache,startTime,temps);  // ici on lance la mecanique
 
        }
 
}

Il faudrait qu'à chaque itération, le temps soit limité.
Voici le code de ma classe:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void examiner(int nb) {
	Scanner sc=new Scanner(System.in);
	créerExamen();
	for (int i=1;i<nb+1;i++) {
		Random r = new Random(0,9);
		int multi = r.getRandom();
		Random rnd = new Random (0,table);
		int rndTable= rnd.getRandom();
		this.afficherExamen(multi, rndTable);
		int rep=sc.nextInt();
		if (rep==(multi+1)*(rndTable+1)) {
			System.out.println("Bravo!");}
		else {
			System.out.println("Dommage! La bonne réponse était "+(multi+1)*(rndTable+1));
		}
	}
	sc.nextLine();
	System.out.println("");
	System.out.println("Terminé!");
}

Merci d'avance!

Salut,

Le souci pour faire de genre de chose est surtout que la lecture clavier sur l'entrée standard est bloquante : dès qu'on appelle une méthode du type nextxxx ou hasnextxxx on bloque le thread qui l'appelle. Donc toute tentative de l'interrompre par timer ou autre est problématique, voire impossible.
Par timer, c'est assez complexe parce qu'il faudrait mettre en place tout un système d'observable et de boucle d'attente. Ce système est déjà procuré par les exécuteurs (ExecutorService) et les Future/FutureTask.

On peut faire quelque chose comme ça (vite fait, pas sûr que ça soit totalement fonctionnel et optimisé) et tu peux voir que c'est déjà assez "usine à gaz" :

Code:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
public class TimeoutScanner implements AutoCloseable {
 
	private final ExecutorService executor = Executors.newSingleThreadExecutor();
	private final BufferedReader reader;
	private final InputStream is;
 
	public TimeoutScanner() {
		this.is=System.in;
		this.reader = new BufferedReader(new InputStreamReader(System.in));
	}
 
	@Override
	public void close() {
		executor.shutdownNow(); // arrêt de l'exécuteur sans attendre que les tâches en cours soient terminées
	}
 
	public Optional<String> readline(int timeout, TimeUnit timeunits) {
		AtomicBoolean stop = new AtomicBoolean(); // permet d'arrêter la boucle de lecture lors d'une exception
		FutureTask<String> readline = new FutureTask<>(()-> {
			boolean ok=false; // vrai si on a lu une ligne, faux sinon
			String response=null;
			do {
				if ( reader.ready() && !stop.get() && !Thread.currentThread().isInterrupted() ) { // on ne lit que s'il y a quelque chose à lire et qu'on a pas annulé la lecture
						response = reader.readLine(); // on lit
						ok=true; // on dit qu'on a lu
				}
			} while( !ok && !Thread.currentThread().isInterrupted()); // tant qu'on a pas lu et qu'on a pas 
			return response;
		});
 
		executor.submit(readline); // lance la tâche
		try {
		    return Optional.of(readline.get(5, TimeUnit.SECONDS));
		} catch (InterruptedException | ExecutionException | TimeoutException e) {
			readline.cancel(true); // force l'annulation de la tâche
			stop.set(true); // pour éviter de commencer à lire et bloquer le thread alors qu'on a annuler
			try {
				while ( is.available()>0 ) reader.read(); // vide le tampon (si l'utilisateur à commencer à taper sans faire entrée)
			} catch (IOException e1) {
			}
		    return Optional.empty();
		} 
 
	}
 
	public Optional<Integer> readInteger(long timeout, TimeUnit timeunits, String errorMessage) {
 
		AtomicBoolean stop = new AtomicBoolean();
		FutureTask<Integer> readline = new FutureTask<>(()-> {
			boolean ok=false;
			Integer response=null;
			do {
				if ( reader.ready() && !stop.get() && !Thread.currentThread().isInterrupted() ) {
					try {
						response = Integer.valueOf(reader.readLine());
						ok=true;
					}
					catch(NumberFormatException e) {
					    System.out.println(errorMessage);
					}
				}
			} while( !ok && !Thread.currentThread().isInterrupted());
			return response;
		});
 
		executor.submit(readline);
		try {
		    return Optional.of(readline.get(5, TimeUnit.SECONDS));
		} catch (InterruptedException | ExecutionException | TimeoutException e) {
			readline.cancel(true);
			stop.set(true);
			try {
				while ( is.available()>0 ) reader.read();
			} catch (IOException e1) {
			}
		    return Optional.empty();
		} 
 
 
	}
 
	public static void main(String[] args) {
 
		try(TimeoutScanner reader = new TimeoutScanner()) {
 
			System.out.println("Vous avez 5 secondes pour taper votre texte...");
			Optional<String> text = reader.readline(5, TimeUnit.SECONDS); // lit une chaîne au clavier en attendant max 5 secondes
			if ( text.isPresent() ) { // si une saisie a été effectuée
				System.out.println("Votre saisie : " + text.get()); 
			}
			else { // si aucune saisie n'a été effectuée
				System.out.println("Trop tard");
			}
 
 
			System.out.println("Vous avez 5 secondes pour taper un nombre...");
			Optional<Integer> value = reader.readInteger(5, TimeUnit.SECONDS, "Un nombre on vous a dit !!!");
			if ( value.isPresent() ) {
				System.out.println("Votre saisie : " + value.get());
			}
			else {
				System.out.println("Trop tard");
			}
 
		}
 
	}
 
}

28/08/2017, 12h31
jeanfils

Salut,

Et merci pour la réponse.
Beaucoup de choses que je ne connais pas encore donc normal que je sois limité ici.
J'essaye de compiler avec ton code mais j'obtiens 2 erreurs sur les lignes de Multi Catch 34 et 69.

"Multiple markers at this line
- TimeoutException cannot be resolved to a type
- ExecutionException cannot be resolved to a type
- No exception of type Object can be thrown; an exception type must be a subclass of
Throwable"

Juste pour info, tu codes depuis combien de siècles? :D
28/08/2017, 13h19
joel.drigo

Citation:

Envoyé par jeanfils

J'essaye de compiler avec ton code mais j'obtiens 2 erreurs sur les lignes de Multi Catch 34 et 69.

Je n'ai pas mis les imports dans mon exemple . Les as-tu bien ajoutés ?

Citation:

Envoyé par jeanfils

Juste pour info, tu codes depuis combien de siècles? :D

Mmfff, ça fait longtemps que je ne compte plus :P
28/08/2017, 14h12
jeanfils

Citation:

Envoyé par joel.drigo

Je n'ai pas mis les imports dans mon exemple . Les as-tu bien ajoutés ?

Oui j'ai tout importé ce qui était importable.
Enfin, je pense...

Voici les imports au cas où il t'en manquerait (ou tu n'aurais pas les bons) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;

Citation:
Envoyé par joel.drigo
Voici les imports au cas où il t'en manquerait (ou tu n'aurais pas les bons) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.util.Optional; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.FutureTask; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean;
Effectivement il me manquait les 2 imports d'Exception.
Merci, je vais essayer de l'implémenter dans mon code.

28/08/2017, 17h57
plawyx

Il y a deux nouvelles méthodes en JDK 9 pour la classe CompletableFuture qui pourraient peut-être t'intéresser:

*) completeOnTimeout(T value,long timeout,TimeUnit unit)

*) orTimeout(long timeout, TimeUnit unit)
29/08/2017, 17h35
thelvin

Bah non, ça ne change rien au problème de la lecture clavier dans la console...