Comment gérer les Loopers et Threads (thread ne meurt pas plus!)

J'ai créé une classe étendant Fil pour récupérer l'emplacement de l'utilisateur par le biais de LocationManager dans un non-thread d'interface utilisateur. J'ai mis en place ce qu'un thread, car il doit être démarré sur demande et faire son travail juste pour un temps limité.
En passant, j'ai dû ajouter un Looper objet dans le thread, pour être en mesure de créer le gestionnaire de l'LocationManager (onLocationChanged).

C'est le code:

public class UserLocationThread extends Thread implements LocationListener {
//...
public void run() {
    try {
        Looper.prepare();
        locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this);
        Looper.loop();
        Looper.myLooper().quit();
    } catch (Exception e) {
        //...
    }
}

@Override
public void onLocationChanged(Location location) {
    locationManager.removeUpdates(this);
    //...
    handler.sendMessage(msg); //this is the handler for communication with father thread
}

//...}

Je voudrais que le thread pour commencer, recevoir de l'utilisateur des données de localisation (dans ce cas il y a un moment), envoyer les données vers le thread principal par l'intermédiaire d'un message au gestionnaire, et puis mourir.
Le problème est que dans mon cas, le thread ne pas mourir de plus, une fois la méthode run terminé (qui devrait être bon, parce que sinon onLocationChanged de ne pas recevoir les nouveaux emplacements).

Mais de cette manière, en supposant que le fil de l'arrêter et suspendre les méthodes sont obsolètes, ce serait un bon moyen, dans ce cas, au moins, de faire un thread avec un looper de mourir?

Merci d'avance 😉

OriginalL'auteur e-cal | 2011-06-08

20

Vous pouvez explicitement quitter Looper'boucle à l'aide de Handler:
```
private Handler mUserLocationHandler = null;
private Handler handler = null;

public class UserLocationThread extends Thread implements LocationListener {    

 public void run() {
    try {
          Looper.prepare();
        mUserLocationHandler = new Handler();
        locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this);
        Looper.loop();

    } catch (Exception e) {
        //...
    }
}


@Override
public void onLocationChanged(Location location) {
    locationManager.removeUpdates(this);
    //...
    handler.sendMessage(msg); 
    if(mUserLocationHandler != null){
        mUserLocationHandler.getLooper().quit();
    }
}
```
Dans mon cas, "gestionnaire" est un Gestionnaire d'objet passé en ce thread le thread appelant, à être utilisé pour transmettre les données collectées à partir de l'une à l'autre. Donc, je ne peux pas appeler gestionnaire.getLooper().quit() parce qu'il se rapporte à l'activité de filetage, et de ne pas le userLocationThread. Notez que onLocationChanged est à l'intérieur du nouveau fil de discussion, et que Looper est nécessaire pour permettre à cette méthode de rappel à appeler lorsque le locationManager reçoit un emplacement.
Lorsque vous appelez Looper.myLooper() vous obtenez Looper associés avec le thread courant. Lorsque vous appelez handler.getLooper() vous obtenez Looper associés à des handler.
Mais si le gestionnaire est associé avec le même fil, le retour de l'Arpenteuse de la devrait être les mêmes, n'est-ce pas?
Oui, si vous créez handler dans le même thread où vous appelez Looper.myLooper(), ils devraient être les mêmes.
Oh, je vois ce que tu veux dire 🙂 Non, dans votre code original vous appelez Looper.myLooper().quit() après l'appel de Looper.mylooper().loop(). Le loop() fonction ne renvoie pas à moins que vous appelez quit(). Et vous appelez quit() après loop(). Donc, fondamentalement, vous n'atteindrez jamais votre quit() et à la fin jusqu'à l'infini loop()🙂

OriginalL'auteur inazaruk
0

"J'ai mis en œuvre ce que la bande de roulement, car il doit être démarré sur demande et faire son travail juste pour un temps limité."

Cela sonne comme une raison parfaite pour simplement réutiliser les principaux looper. Il n'y a pas besoin de lancer un nouveau Fil de discussion ici. Si vous êtes en train de faire le blocage de travail (e/S réseau, etc) dans onLocationChanged(), à ce stade, vous pourriez faire tourner un ASyncTask.

Mettre en œuvre: LocationListener sur votre Activité/Service ou quoi que ce soit et permettre d'utiliser les principales looper par défaut.

Fraie un nouveau fil de discussion, le mettre en boucle, puis immédiatement cesser de fumer n'est pas nécessaire.

OriginalL'auteur 43matthew
0

IntentService est bon pour faire ce travail.

IntentService est une classe de base pour les Services qui gèrent les requêtes asynchrones (exprimé en Intentions) sur demande. Les Clients envoient des requêtes à travers startService(Intent) appelle; le service est démarré en tant que de besoin, les poignées de chaque Intention de tourner à l'aide d'un thread de travail, et s'arrête de lui-même quand il est à court de travail.

OriginalL'auteur Davide
0

Looper().quit(); est bon, et conformément à la spécification:

Provoque la boucle() la méthode de résilier le contrat sans traitement de plus de messages dans la file d'attente de messages.

Mais, si vous avez une tâche qui est déjà en cours de traitement, et que vous voulez arrêter de trop, vous pouvez vous procurer du fil de travail et de l'amener à interrompre:
```
@Override
public void onLocationChanged(Location location) {
    locationManager.removeUpdates(this);
    handler.sendMessage(msg); //this is the handler for communication with father thread
    if(mUserLocationHandler != null){
        mUserLocationHandler.getLooper().quit();
        mUserLocationHandler.getLooper().getThread().interrupt(); //<-- here
    }
```
}

Cela fonctionne bien avec la plupart des IO, et le fil de verrouillage/d'attente.

OriginalL'auteur msangel
-1

Prolonger la AsyncTask classe. Il fait tout le filetage et de manutention pour vous automatiquement.

Je ne pense AsyncTask travaillera dans ce cas que le thread a avoir Looper boucle.

OriginalL'auteur jederik

Vous devez vous connecter pour publier un commentaire.