能否在AsyncTask的doInBackground()中实现持续位置更新？

Great question! Let's break this down step by step—there are a few key gotchas with your initial approach, and I'll show you how to make it work (plus some important caveats to keep in mind).

First, why your initial idea won't work directly #

The doInBackground() method runs on a background thread and executes only once—it finishes as soon as its code block completes. Meanwhile, the LocationListener's onLocationChanged() callback is triggered on the main thread every time a new location is received. You can't "process location changes inside doInBackground()" directly because those callbacks happen outside of that single background execution cycle.

How to implement continuous location updates with AsyncTask #

If you still want to use AsyncTask for this (even though it's deprecated now—more on that later), here's a workable approach using a thread-safe queue to pass location data from the main thread listener to the background processing thread:

Step 1: Create the AsyncTask with a thread-safe queue

We'll use a BlockingQueue to safely pass Location objects from the main thread's onLocationChanged() to the background thread in doInBackground().

import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.AsyncTask;
import android.os.Bundle;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class LocationUpdateTask extends AsyncTask<Void, String, Void> {
    private LocationManager locationManager;
    private BlockingQueue<Location> locationQueue;
    private LocationListener locationListener;
    private boolean taskCancelled = false;

    public LocationUpdateTask(LocationManager manager) {
        this.locationManager = manager;
        this.locationQueue = new LinkedBlockingQueue<>();
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // Initialize location listener (runs on main thread)
        locationListener = new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                // Add new location to the thread-safe queue
                try {
                    locationQueue.put(location);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }

            @Override
            public void onStatusChanged(String provider, int status, Bundle extras) {}

            @Override
            public void onProviderEnabled(String provider) {}

            @Override
            public void onProviderDisabled(String provider) {}
        };

        // Request location updates (runs on main thread)
        try {
            locationManager.requestLocationUpdates(
                LocationManager.GPS_PROVIDER,
                1000, // Minimum time between updates (ms)
                1,    // Minimum distance between updates (meters)
                locationListener
            );
        } catch (SecurityException e) {
            // Handle missing location permissions (request them first!)
            cancel(true);
        }
    }

    @Override
    protected Void doInBackground(Void... voids) {
        while (!taskCancelled) {
            try {
                // Wait for a new location from the queue
                Location location = locationQueue.take();
                // Process the location in the background thread
                String processedData = processLocation(location);
                // Send processed data to main thread for UI updates if needed
                publishProgress(processedData);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        return null;
    }

    private String processLocation(Location location) {
        // Example processing: format coordinates, save to database, etc.
        return String.format("Current location: %.6f, %.6f", 
            location.getLatitude(), location.getLongitude());
    }

    @Override
    protected void onProgressUpdate(String... values) {
        super.onProgressUpdate(values);
        // Update UI here (runs on main thread)
        // e.g., locationTextView.setText(values[0]);
    }

    @Override
    protected void onCancelled() {
        super.onCancelled();
        taskCancelled = true;
        // Critical: Remove location listener to avoid memory leaks
        if (locationManager != null && locationListener != null) {
            locationManager.removeUpdates(locationListener);
        }
    }
}

Step 2: Use the AsyncTask in your Activity/Fragment

Make sure you've requested the necessary location permissions (ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION) first, then initialize and execute the task:

// In your Activity
private LocationUpdateTask locationTask;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    locationTask = new LocationUpdateTask(locationManager);
    locationTask.execute();
}

// Always cancel the task when the activity is destroyed to stop updates
@Override
protected void onDestroy() {
    super.onDestroy();
    if (locationTask != null && !locationTask.isCancelled()) {
        locationTask.cancel(true);
    }
}

Important Caveats & Better Alternatives #

• AsyncTask is deprecated: Google officially deprecated AsyncTask in API 30. For modern Android development, use Coroutines (with lifecycleScope for lifecycle-aware tasks) or WorkManager (for persistent background location tracking).
• Memory leaks: Failing to remove the LocationListener when the task is cancelled or the Activity is destroyed will leak the Activity context. Always call cancel(true) and removeUpdates() when you're done.
• Battery efficiency: Continuous location updates drain battery quickly. Adjust the minTime and minDistance parameters to balance accuracy and battery life based on your use case.

内容的提问来源于stack exchange，提问作者viperjonis