Android Service管理：避免重复启动与数据传递的最佳实践

public class ForegroundService extends Service {
    // 这里的变量在Service实例创建时初始化，之后不会重新赋值
    double x1 = MainActivity.x1;
    double y1 = MainActivity.y1;
    // ...

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 每次onStartCommand被调用，都会启动一个新的线程
        new Thread(
            new Runnable() {
                @Override
                public void run() {
                    while (true) { // 线程会一直运行
                        Log.e("Service", "Running " + String.valueOf(x1)); // 使用的是Service创建时的x1值
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        ).start();
        return super.onStartCommand(intent, flags, startId);
    }
    // ...
}

import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {

    private double currentX1 = 35.0;
    private double currentY1 = 40.0;
    private double currentRadius = 10.0;
    private int currentK = 5;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main); // 假设你有一个布局文件

        Button startServiceButton = findViewById(R.id.start_service_button); // 假设有这个按钮
        startServiceButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startOrUpdateMyService();
            }
        });

        Button updateValuesButton = findViewById(R.id.update_values_button); // 假设有这个按钮
        updateValuesButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 模拟更新值
                currentX1 += 0.5;
                currentY1 += 0.2;
                currentRadius += 0.1;
                currentK++;
                startOrUpdateMyService(); // 再次启动/更新Service
            }
        });

        Button stopServiceButton = findViewById(R.id.stop_service_button); // 假设有这个按钮
        stopServiceButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent serviceIntent = new Intent(MainActivity.this, MyForegroundService.class);
                stopService(serviceIntent); // 停止服务
            }
        });
    }

    private void startOrUpdateMyService() {
        Intent serviceIntent = new Intent(this, MyForegroundService.class);
        // 通过Intent extras传递数据
        serviceIntent.putExtra("x1_key", currentX1);
        serviceIntent.putExtra("y1_key", currentY1);
        serviceIntent.putExtra("radius_key", currentRadius);
        serviceIntent.putExtra("k_key", currentK);
        startService(serviceIntent);
    }
}

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
import androidx.annotation.Nullable;

public class MyForegroundService extends Service {

    // 使用volatile确保多线程环境下变量的可见性
    private volatile double x1_val;
    private volatile double y1_val;
    private volatile double radius_val;
    private volatile int k_val;

    private Thread backgroundThread;
    private volatile boolean isRunning = false; // 控制线程循环的标志

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("MyForegroundService", "Service created.");
        // 初始化默认值或从持久化存储中加载
        x1_val = 0.0;
        y1_val = 0.0;
        radius_val = 0.0;
        k_val = 0;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("MyForegroundService", "onStartCommand called.");

        // 从Intent中获取最新的数据
        if (intent != null) {
            x1_val = intent.getDoubleExtra("x1_key", x1_val); // 如果Intent中没有，则保留当前值
            y1_val = intent.getDoubleExtra("y1_key", y1_val);
            radius_val = intent.getDoubleExtra("radius_key", radius_val);
            k_val = intent.getIntExtra("k_key", k_val);
            Log.d("MyForegroundService", "Values updated: x1=" + x1_val + ", y1=" + y1_val);
        }

        // 检查后台线程是否已在运行
        if (backgroundThread == null || !backgroundThread.isAlive()) {
            // 如果线程未运行，则启动新线程
            isRunning = true;
            backgroundThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (isRunning) { // 使用isRunning标志控制循环
                        Log.e("MyServiceThread", "Running with X1: " + x1_val + ", Y1: " + y1_val + ", Radius: " + radius_val + ", K: " + k_val);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt(); // 恢复中断状态
                            Log.e("MyServiceThread", "Thread interrupted, stopping.");
                            break; // 线程中断时退出循环
                        }
                    }
                    Log.d("MyServiceThread", "Background thread finished execution.");
                }
            });
            backgroundThread.start();
            Log.d("MyForegroundService", "New background thread started.");
        } else {
            // 如果线程已在运行，则仅更新参数。由于x1_val等是volatile，线程会读取到最新值。
            Log.d("MyForegroundService", "Service already running, parameters updated for existing thread.");
        }

        // START_STICKY: 如果Service被系统杀死，系统会尝试重新创建Service并调用onStartCommand，但不会传递上次的Intent。
        // START_NOT_STICKY: Service被杀死后不会自动重启。
        // START_REDELIVER_INTENT: Service被杀死后，系统会尝试重新创建Service并重新传递最后一次的Intent。
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyForegroundService", "Service destroyed.");
        // 停止后台线程
        isRunning = false; // 设置标志位，通知线程停止
        if (backgroundThread != null) {
            backgroundThread.interrupt(); // 中断线程，使其退出sleep状态
            try {
                backgroundThread.join(1000); // 等待线程终止，最多1秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                Log.e("MyForegroundService", "Interrupted while waiting for thread to finish.");
            }
            backgroundThread = null; // 清空引用
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.yourapp">

    <application
        ...
        <service
            android:name=".MyForegroundService"
            android:enabled="true"
            android:exported="false" />
        ...
    </application>
</manifest>