Question

我每隔20秒就会根据Alarm Manager启动一项服务，将GPS数据发送到我的服务器。问题是我的堆和分配的堆大小继续增加。当我分析堆转储时，我发现服务实例的数量等于对startService()的调用次数。如何避免这个问题？

public class SystemBootListener extends BroadcastReceiver {

// Restart service every 30 seconds
private static final long REPEAT_TIME = 1000 * 10;

    @Override
    public void onReceive(Context context, Intent intent) {

        Intent i = new Intent(context, StartLocationServiceAfterReboot.class);
        PendingIntent pending = PendingIntent.getBroadcast(context, 0, PendingIntent.FLAG_UPDATE_CURRENT);

        // Start 20 seconds after boot completed - so that all providers are initialized by then
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.SECOND, 20);

        // Trigger every 10 seconds
        // InexactRepeating allows Android to optimize the energy consumption
        AlarmManager service = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        service.setInexactRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), REPEAT_TIME, pending);
    }
}

public class StartLocationServiceAfterReboot extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

        if(AppSettings.isRouteConfigured(context)){
            AppSettings.setServiceRunning(context, Boolean.TRUE);
            Intent service = new Intent(context, GPSComputationService.class);
            context.startService(service);
        }
    }
}

public class GPSComputationService extends Service {

    private static final int MAX_TIME_TO_FETCH_NEW_LOCATION = 8000;

    private final IBinder mBinder = new ServiceBinder();

    private Timer timerToFetchLocInfoFromProviders = null;

    private LocationManager locationManager = null;

    private boolean gpsProviderEnabled=false;

    private boolean networkProviderEnabled=false;

    private int numberOfSatellites = 0;

    private GPSData bestKnownLocation = new GPSData();


    private TCPWriter tcpWriter  ;


    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        tcpWriter= new TCPWriter(this);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        /*tcpWriter= new TCPWriter(this);*/
        computeBestLocation();
        return Service.START_STICKY;
    }

    private void stopGPSComputationService(){
        stopSelf();
    }


    @Override
    public IBinder onBind(Intent arg0) {
        return mBinder;
    }

    public class ServiceBinder extends Binder {
        public GPSComputationService getService() {
            return GPSComputationService.this;
        }
    }


    public GPSData getBestKnownLocation() {
        return bestKnownLocation;
    }

    public void publishBestKnownLocation(GPSData bestKnownLocation) {
        this.bestKnownLocation = bestKnownLocation;
        sendBestKnownLocationToNMEAServer();

    }


    public void sendBestKnownLocationToNMEAServer(){

        if(getBestKnownLocation() == null){
            stopGPSComputationService();
            return;
        }

        TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
        telephonyManager.getDeviceId();

        NMEAData dataPacketToWrite = new NMEAData(
              telephonyManager.getDeviceId(),
              getBestKnownLocation().getLatitude(),
              getBestKnownLocation().getLongitude(),
              getBestKnownLocation().getTimeStamp(),
              getBestKnownLocation().getSpeed(),
              getBestKnownLocation().getNumberOfSatellites()
              );

        tcpWriter.sendMessage(NMEAServerTypes.MVT600, 
              dataPacketToWrite);
        stopGPSComputationService();
    }



    public GPSData computeBestLocation()   {
        Log.d("#############GPSComputation Status", "Running.......");

        try{
                 if(locationManager==null)
                  locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

                 //Add status listener for satellite count
                 locationManager.addGpsStatusListener(gpsStatusListener);


                 Criteria criteria = new Criteria();
                 criteria.setSpeedRequired(true);
                 criteria.setBearingRequired(true);
                 List<String> providers = locationManager.getProviders(criteria, false);


                //Capture if the GPS/Network providers have been disabled.
                try{
                    gpsProviderEnabled=providers.contains(LocationManager.GPS_PROVIDER) && 
                            locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
                }catch(Exception e){

                }

                try{
                    networkProviderEnabled=providers.contains(LocationManager.NETWORK_PROVIDER) && 
                            locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
                }catch(Exception e){

                }

                if(!gpsProviderEnabled && !networkProviderEnabled)
                    return null;

                if(gpsProviderEnabled)
                    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListenerGps);

                if(networkProviderEnabled)
                    locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListenerNetwork);

                timerToFetchLocInfoFromProviders=new Timer();
                timerToFetchLocInfoFromProviders.schedule(new GetLastKnownGoodLocation(), MAX_TIME_TO_FETCH_NEW_LOCATION);
                locationManager.removeGpsStatusListener(gpsStatusListener);

                //Finally store the data in backend Service
                return getBestKnownLocation() ;

        }catch(Exception e){

            return null;
        }
    }

    LocationListener locationListenerGps = new LocationListener() {
        public void onLocationChanged(Location location) {
            timerToFetchLocInfoFromProviders.cancel();
            publishBestKnownLocation(extractAllGeoInfFromLocation(location));
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerNetwork);
            locationManager.removeGpsStatusListener(gpsStatusListener);
            gpsStatusListener = null;
        }

        public void onProviderDisabled(String provider) {

        }
        public void onProviderEnabled(String provider) {

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

        }
    };


    //listen for gps status changes to capture number of satellites.
    GpsStatus.Listener gpsStatusListener = new GpsStatus.Listener() {
        @Override
        public void onGpsStatusChanged(int event) {
            if (event == GpsStatus.GPS_EVENT_SATELLITE_STATUS || event == GpsStatus.GPS_EVENT_FIRST_FIX) {
                GpsStatus status = locationManager.getGpsStatus(null);
                Iterable<GpsSatellite> sats = status.getSatellites();
                // Check number of satellites in list to determine fix state
                int tempNumberOfSatellites = 0;
                for (GpsSatellite sat : sats) {
                    if(sat.usedInFix())
                        tempNumberOfSatellites++;
                }
                numberOfSatellites = tempNumberOfSatellites;

            }
        }
    };


    LocationListener locationListenerNetwork = new LocationListener() {
        public void onLocationChanged(Location location) {


            timerToFetchLocInfoFromProviders.cancel();
            publishBestKnownLocation(extractAllGeoInfFromLocation(location));
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerGps);
        }

        public void onProviderDisabled(String provider) {

        }
        public void onProviderEnabled(String provider) {

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

        }
    };

    class GetLastKnownGoodLocation extends TimerTask {
        @Override
        public void run() {
             locationManager.removeUpdates(locationListenerGps);
             locationManager.removeUpdates(locationListenerNetwork);

             Location bestKnownNetworkLocation = null, bestKnownGPSLocation=null;

             if(gpsProviderEnabled)
                 bestKnownGPSLocation=locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
             if(networkProviderEnabled)
                 bestKnownNetworkLocation=locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

             if(bestKnownGPSLocation!=null && bestKnownNetworkLocation!=null){
                 if(bestKnownGPSLocation.getTime()>bestKnownNetworkLocation.getTime())
                     publishBestKnownLocation(extractAllGeoInfFromLocation(bestKnownGPSLocation));
                 else
                     publishBestKnownLocation(extractAllGeoInfFromLocation(bestKnownNetworkLocation));
                 return;
             }

             if(bestKnownGPSLocation!=null){
                 publishBestKnownLocation(extractAllGeoInfFromLocation(bestKnownGPSLocation));
                 return;
             }
             if(bestKnownNetworkLocation!=null){
                 publishBestKnownLocation(extractAllGeoInfFromLocation(bestKnownNetworkLocation));
                 return;
             }
             AppLog.logWarningMsg("Bad luck-NO BEST LOCATION AVAILABLE");
             publishBestKnownLocation(null);
        }
    }

    private GPSData extractAllGeoInfFromLocation(Location location){
        bestKnownLocation = new GPSData();
        bestKnownLocation.setLatitude(location.getLatitude());  
        bestKnownLocation.setLongitude(location.getLongitude());    
        bestKnownLocation.setTimeStamp(location.getTime());
        bestKnownLocation.setSpeed(location.getSpeed()*3.8);
        bestKnownLocation.setNumberOfSatellites(numberOfSatellites);
        return bestKnownLocation;
    }
}

Answer 1

只有一个服务实例。根据{{3}}

对Context.startService（）的多次调用会导致对onStartCommand（）的多次相应调用， 但是只能存在一个服务实例。

在startService（）上，Android系统调用服务的onStartCommand（）方法。如果服务尚未运行，系统首先调用onCreate（），然后调用onStartCommand（）。

Answer 2

唯一可以创建这种情况的是你有某种内存泄漏。你的服务做了它的工作并停止了但没有收集垃圾。它可能会发生几次，这就是为什么你会看到它的很多实例。

很难找到内存泄漏，但我建议你从听众开始。检查您是否在合适的时间取消注册。

此链接可以帮助您检测泄漏： https://developer.android.com/studio/profile/am-memory.html

Answer 3

一些改进和简化代码的技巧：

您要使用一项拍摄服务来报告GPS坐标。为此，IntentService更好，它是按设计在后台线程中运行的。 https://developer.android.com/training/run-background-service/create-service
使用PendingIntent.getService()代替仅启动其他Android组件的调用StartLocationServiceAfterReboot。您可以立即这样做。您节省了一步。 https://developer.android.com/reference/android/app/PendingIntent.html#getService(android.content.Context,%2520int,%2520android.content.Intent,%2520int)
每次使用资源（例如GPS，Sensor等）时，都必须同时编写发行部分。如我所见，您向GPS服务注册了侦听器，但从未释放（取消注册）它们。
AppSettings.setServiceRunning(context, Boolean.TRUE);是什么？我猜您将其保存到SharedPreference中。当应用强制停止，设备重新启动或突然关闭时，这可能会受到损害。也许更好的方法是https://stackoverflow.com/a/5921190/5823014
避免在Context，Activity，Service，BroadcastReceiver，Application实例上使用static。在您的代码段中没有看到我，只是防止内存泄漏的一般建议。

如何修复服务实例问题？

3 个答案: