在我的代码中，我使用 IntentService 来监听位置更新(GPS 或网络更新)，并且此 IntentService 在收到事件时触发，所以它由任何 Activity 的 startService() 启动。

public class AddLocationService extends IntentService implements LocationListener {
    /*My code here*/
}

    @Override
protected void onHandleIntent(Intent intent) {
    if(getOldLoc() == null) 
    { 
        //Get a new location
        this.locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, TIME_INTERVAL_GPS, 0, this);
        this.locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, TIME_INTERVAL_GPS, 0, this);
        Log.d(AddLocationService.TAG, "Network listener started");

        this.time_start_listening = System.currentTimeMillis();
        mTimerThread mTimerRunnable = new mTimerThread();
        this.timerThread = new Thread(mTimerRunnable);
        this.timerThread.start();
    }
    else    
        /*REUSE OLD LOCATION*/
}

现在我的问题是:当两个事件启动此 IntentService 并且第二个启动它时第一个仍在请求更新，我希望第二个等到第一个完全完成(找到位置或计时器线程完成)。 但是，每当 IntentService 第二次执行时(第一个实例仍在运行)，它会向我打印日志并按照并行执行的方式执行。

但是我认为 IntentService 的主要目标是它是顺序的，所以第二个 Intent 必须等到第一个 Intent 完成...

我是不是误会了什么？

最佳答案

您的 onHandleIntent 方法似乎没有阻塞它正在执行的线程，因此它将快速返回并允许处理第二个 Intent 。不仅如此，从 LocationManager 到该线程的任何回调都不太可能得到处理，因为后台线程很可能在 onHandleIntent 完成时被杀死。

如果你真的想使用 IntentService 来管理你的 Intent 队列，那么你需要在它自己的线程上处理你的位置，并在等待位置回调时将 IntentService 线程加入到位置线程。

下面是一些演示这个想法的代码:

public class TestService extends IntentService {
    private static final String TAG = "TestService";

    private Location mLocation = null;

    public TestService() {
       super(TAG);
    }

    @Override
    public void onHandleIntent(Intent intent) {
        Log.d(TAG, "onHandleIntent");

        if (mLocation == null) {
            Log.d(TAG, "launching location thread");
            LocationManager locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);

            LocationThread thread = new LocationThread(locationManager);
            thread.start();
            try {
                thread.join(10000);
            } catch (InterruptedException e) {
                Log.d(TAG, "timeout");
                return;
            }

            Log.d(TAG, "join finished, loc="+mLocation.toString());
        } else {
             Log.d(TAG, "using existing loc="+mLocation.toString());
        }
    }

    private class LocationThread extends Thread implements LocationListener  {
        private LocationManager locationManager = null;

        public LocationThread(LocationManager locationManager) {
            super("UploaderService-Uploader");
            this.locationManager = locationManager;
        }

        @Override
        public void run() {
            Log.d(TAG, "Thread.run");
            Looper.prepare();
           this.locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this);
            this.locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);

            Looper.loop();
        }

        @Override
        public void onLocationChanged(Location location) {
            // TODO Auto-generated method stub
            Log.d(TAG, "onLocationChanged("+location.toString()+")");
            mLocation = location;
            Looper.myLooper().quit();
         }

         @Override
         public void onProviderDisabled(String arg0) {
         }

         @Override
         public void onProviderEnabled(String arg0) {
         }

         @Override
         public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
         }

   }
}

有趣的是 Looper 在线程上运行消息循环(以允许处理回调)。

鉴于使用 IntentService 执行此操作所需的工作，可能值得研究从 Service 派生并管理您自己的 Intent 队列。

关于android - Intent 服务 : How to enqueue correctly?，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6866415/