Après le démarrage d'un thread comment pourrions-nous garder la fonction d'exécution en cours d'exécution? J'ai des tas d'idées, mais je ne suis pas sûr de ce qui est plus professionnel?
Dans un Thread
Après l'appel de la start()
comme vous le savez, il va appeler le run()
fonction dans le Runnable
classe. Dans le run()
fonction je veux le fil reste aussi longtemps qu'il reçoit le "au Revoir" message de la part du client. Si je les ai mis dans la boucle while, il prend des tas de mémoire, je pense, et je ne suis pas en utilisant la puissance de fil. Par la façon dont je ne veux pas que mon fils dormir dans la fonction d'exécution en appelant Thread.sleep(6000);
Est-il un autre moyen de rester là, dans la fonction d'exécution?
- Si la réponse est de rejoindre où et comment l'utiliser? Dois-je de la pop au début de la course de la fonction et il y reste jusqu'à ce que j'envoie le "au Revoir" de la client?
- Devrais-je dire
while((request=in.readLine())!=null){
? Il n'a pas de travail parce que je pense qu'il va perdre la connexion avec le client ou pour mieux dire, client de perdre la connexion? - Devrais-je dire
while(Thread.isAlive)
et ensuite de tuer la menace lorsque je reçois le "au Revoir" en appelantThread.stop
qui est un peu dangereux?
Voici mon code simplifié:
while(true)
{
ClientWorker w;
try
{
w = new ClientWorker(serverSocket.accept());
Thread t = new Thread(w);
t.start();
}
...... }
class ClientWorker implements Runnable {
public ClientWorker(Socket incoming)
{
myList = my;
this.incoming = incoming;
}
public synchronized void run()
{
in = new BufferedReader(new InputStreamReader(incoming.getInputStream()));
.
.
..
...
}
Je suis vraiment perdu quant à ce problème que vous essayez de résoudre ici. Je voudrais commencer par la solution la plus simple possible et ne pas essayer de résoudre des problèmes qui ne pourrait jamais arriver à démarrer avec.
Peut-être que ma question n'est pas claire. J'essaie de rester int la fonction run. c'est ensemble.
qu'est-ce que vous empêche de rester dans la méthode run ()? par exemple, à l'aide de la boucle while que vous avez suggéré.
Je n'ai pas voulu utiliser tout parce qu'il passe par tous les codes dans la course de la fonction et c'est une sorte de boucle. Je suis à la recherche de quelque chose par exemple dans ServerSocket, nous avons une fonction appelée la demande() qui est en attente d'un appel à partir du serveur!
Si vous voulez avoir un écouteur d'événements comme quand une nouvelle ligne peut être lu? Vous pouvez écrire un si vous le souhaitez.
Peut-être que ma question n'est pas claire. J'essaie de rester int la fonction run. c'est ensemble.
qu'est-ce que vous empêche de rester dans la méthode run ()? par exemple, à l'aide de la boucle while que vous avez suggéré.
Je n'ai pas voulu utiliser tout parce qu'il passe par tous les codes dans la course de la fonction et c'est une sorte de boucle. Je suis à la recherche de quelque chose par exemple dans ServerSocket, nous avons une fonction appelée la demande() qui est en attente d'un appel à partir du serveur!
Si vous voulez avoir un écouteur d'événements comme quand une nouvelle ligne peut être lu? Vous pouvez écrire un si vous le souhaitez.
OriginalL'auteur Bernard | 2012-10-17
Vous devez vous connecter pour publier un commentaire.
Dans le cas le plus simple il suffit de laisser votre méthode de course faire son travail et de mettre fin lorsque cela est approprié, quelque chose comme ceci:
Ici, le processus s'arrête lorsque la doWork() la méthode renvoie la valeur false. Il est également bon style pour permettre à votre fil d'être interrompu, surtout si il a besoin pour fonctionner pendant une longue période, voir ce tutoriel. Pour tout ce travail, doWork() doit retourner régulièrement. Remarque vous ne pouvez pas redémarrer fils, une fois l'exécution de la méthode a repris le fil est récupéré par le système.
Si vous avez besoin de plus de contrôle sur votre fils que vous pourriez créer différents Travailleur et ThreadManager classes.
Pour laisser le ThreadManager résilier le Travailleur, créer un volatile champ booléen dans votre Travailleur qui est vérifié périodiquement:
Le Travailleur se termine lorsqu'il est interrompu ou lorsque le travail est terminé. Aussi la ThreadManager peut demander au Travailleur de s'arrêter par l'invocation de la stopRunning() la méthode.
Si votre fil est à court de travail, il peut aussi appeler wait() la méthode sur la ThreadManager. Cela interrompt le fil jusqu'à ce qu'il est informé qu'il ya un nouveau travail à faire. Le ThreadManager doit appeler notify() ou notifyAll() quand un nouveau travail arrive (ThreadManager est utilisé comme un moniteur dans cet exemple).
Avec cette approche, vous pouvez garder le Travailleur simple et le seul souci de faire le travail. Le ThreadManager détermine le nombre de threads et rend le travail à leur disposition, mais n'a pas besoin de connaître tous les détails du travail réel. Un pas de plus serait de séparer "travail" dans une classe distincte, ce qui vous pourrait appeler de l'Emploi. Un exemple de ceci peut être trouvé dans mon webcrawler exemple. Cela pourrait être utile pour l'adoption d'une nouvelle œuvre à partir de la ThreadManager pour le thread de travail.
Personne ne sait d'une façon de le faire sans occupé attente? Peut-être une variable de condition? Je ne suis pas sûr de la syntaxe java.
Voir la webcrawler exemple ci-dessus, il utilise le java wait/notify mécanisme pour éviter occupé attente. Une autre approche est le modèle Observateur qui utilise un rappel asynchrone à informer les serveurs d'un événement.
OriginalL'auteur Adriaan Koster
juste
return
de larun()
lorsque vous obtenez"bye"
ouais, tandis que la boucle est fine. exécutez le tout en boucle et à chaque fois que vous obtenez le message "au revoir" de retour d'appel.
Voulez-vous dire alors que la boucle à l'intérieur de la méthode run?
ouais. alors que doivent être à l'intérieur de la méthode run
bien, merci pour le commentaire.
OriginalL'auteur taufique
Je sais c'est tard, mais c'est une bien meilleure mise en œuvre et évite de lourds d'utilisation de l'UC par occupé attente - Permet la commutation de contexte lorsque le thread est en attente d'un signal.
Réglage du sémaphore à une valeur de 0 garantit que lorsque le thread tente d'obtenir l'autorisation de continuer, il ne l'obtient pas et attend. Lorsque vous relâchez le sémaphore, le nombre est augmenté de 1, permettant le fil de continuer, et leur nombre a diminué à 0.
Principal:
Le Fil
OriginalL'auteur Riptyde4