Fil de sommeil et le fil rejoindre
si j'ai mis un fil de dormir dans une boucle, netbeans me donne une mise en garde en disant Invoquant Fil.dormir dans la boucle peut provoquer des problèmes de performances. Cependant, si j'étais à la place de la veille avec une jointure, aucune attention n'est donnée. Les deux versions de compiler et fonctionner correctement tho. Mon code est ci-dessous (cocher les dernières lignes de "Thread.sleep()
vs t.join()
").
public class Test{
//Display a message, preceded by the name of the current thread
static void threadMessage(String message) {
String threadName = Thread.currentThread().getName();
System.out.format("%s: %s%n", threadName, message);
}
private static class MessageLoop implements Runnable {
public void run() {
String importantInfo[] = {
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too"
};
try {
for (int i = 0; i < importantInfo.length; i++) {
//Pause for 4 seconds
Thread.sleep(4000);
//Print a message
threadMessage(importantInfo[i]);
}
} catch (InterruptedException e) {
threadMessage("I wasn't done!");
}
}
}
public static void main(String args[]) throws InterruptedException {
//Delay, in milliseconds before we interrupt MessageLoop
//thread (default one hour).
long patience = 1000 * 60 * 60;
//If command line argument present, gives patience in seconds.
if (args.length > 0) {
try {
patience = Long.parseLong(args[0]) * 1000;
} catch (NumberFormatException e) {
System.err.println("Argument must be an integer.");
System.exit(1);
}
}
threadMessage("Starting MessageLoop thread");
long startTime = System.currentTimeMillis();
Thread t = new Thread(new MessageLoop());
t.start();
threadMessage("Waiting for MessageLoop thread to finish");
//loop until MessageLoop thread exits
while (t.isAlive()) {
threadMessage("Still waiting...");
//Wait maximum of 1 second for MessageLoop thread to
//finish.
/*******LOOK HERE**********************/
Thread.sleep(1000);//issues caution unlike t.join(1000)
/**************************************/
if (((System.currentTimeMillis() - startTime) > patience) &&
t.isAlive()) {
threadMessage("Tired of waiting!");
t.interrupt();
//Shouldn't be long now -- wait indefinitely
t.join();
}
}
threadMessage("Finally!");
}
}
Ce que je comprends, rejoignez attend de l'autre thread, mais dans ce cas, arent à la fois du sommeil et de rejoindre faire la même chose? Alors pourquoi ne netbeans jeter la prudence?
cette stackoverflow.com/questions/3535754/... peut aider
ouais, j'ai effectivement vu ce thread avant de poster. cependant, cette question est complètement différent (je sais la cause de l'attention, mais ne sais pas pourquoi il le fait dans ce cas). merci pour vos commentaires! beaucoup apprécié!
ouais, j'ai effectivement vu ce thread avant de poster. cependant, cette question est complètement différent (je sais la cause de l'attention, mais ne sais pas pourquoi il le fait dans ce cas). merci pour vos commentaires! beaucoup apprécié!
OriginalL'auteur Dhruv Gairola | 2010-12-30
Vous devez vous connecter pour publier un commentaire.
Il y a une différence entre join() et sleep(). join() va attendre jusqu'à l'expiration du délai ou le thread se termine. sleep() va juste attendre que le laps de temps spécifié, sauf interrompu. Donc c'est parfaitement possible pour les join() pour renvoyer beaucoup plus rapide que le temps spécifié.
La raison pour laquelle Netbeans vous avertit en cas de sleep() et non pas sur join() est précisément cette différence. join() attend quelque chose de significatif, tandis que sleep() est juste assis là à ne rien faire. Si vous n'êtes pas en attente de quelque chose, alors pourquoi voudriez-vous attendre? Il est rarement significatif, d'où l'avertissement.
OriginalL'auteur Sergei Tachenov
Qu'ils peuvent être utilisés pour obtenir la même chose ne signifie pas qu'ils sont victimes de la même manière. Souvent, les gens abus
Thread.sleep()
quand ils devraient vraiment utiliser un verrou ou quelque chose qui bloque:Dans votre cas, il n'y a pas de différence; Netbeans donne juste un avertissement pour
sleep()
.Je pense que la jointure est mieux alaternative que l'utilisation d'une serrure ...
euh, par "lock" vous voulez dire que le sommeil, non? et par "meilleure solution", tu veux dire meilleure solution dans ce cas précis, non?
La minuterie ne doit pas être utilisé à partir de Java 5 et suivants. Une meilleure alternative est d'utiliser ScheduledThreadPoolExecutor ...
OriginalL'auteur Aaron Digulla
Pour ce cas, je pense que la jointure est une meilleure alternative que l'utilisation d'un verrou.. jointure est simple et élégant. Mais si vous utilisez un verrou, vous devez également utiliser la méthode de notification , et la synchronisation de bloc et bien sûr, vous avez besoin d'un verrou de l'objet.
rejoindre l'échantillon , le thread appelant code ;
de verrouillage de l'échantillon : thread appelant code ;
Objet de verrouillage = new Object();
}
Ici est thread t1 code;
OriginalL'auteur Gursel Koca