Java 我希望每X秒执行一次代码，但handler.postdayed不起作用

好的，我想每X秒将加速度计值注册到我的数据库中。他接受了第一个延迟，但忽略了第二个处理程序。postDelayed，有人知道它可能是什么吗？我试过用计时器，但也没用，所以我这里的选项有点少了

代码如下：

public class MainActivity extends AppCompatActivity implements SensorEventListener{

private Button receiveButton;
private ListView listView;

private DatabaseReference database;

private ArrayAdapter<String> adapter;
private List<String> items;

private SensorManager sensorManager;
private Sensor senAccelerometer;

private Handler handler = new Handler();
private final int delay = 5000; //in milliseconds

private Accelerometer accelerometer;

private float xValue;
private float yValue;
private float zValue;

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

    sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    senAccelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    sensorManager.registerListener(this, senAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);

    receiveButton = findViewById(R.id.receiveButton);
    listView = findViewById(R.id.listView);

    database = FirebaseDatabase.getInstance().getReference("Accelerometer");

    items = new ArrayList<>();


    items.add("X Value: " + Float.toString(xValue));
    items.add("Y Value: " + Float.toString(yValue));
    items.add("Z Value: " + Float.toString(zValue));
    updateUI();

    receiveButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            database.addValueEventListener(new ValueEventListener() {
                @Override
                public void onDataChange(DataSnapshot dataSnapshot) {
                    Accelerometer accelerometer = dataSnapshot.getValue(Accelerometer.class);
                    xValue = accelerometer.xValue;
                    yValue = accelerometer.yValue;
                    zValue = accelerometer.zValue;
                    for (Iterator<String> iterator = items.iterator(); iterator.hasNext();){
                        iterator.next();
                        iterator.remove();
                    }
                    items.add("X Value: " + Float.toString(xValue));
                    items.add("Y Value: " + Float.toString(yValue));
                    items.add("Z Value: " + Float.toString(zValue));
                }

                @Override
                public void onCancelled(DatabaseError databaseError) {

                }
            });
            updateUI();
        }
    });
}

private void updateUI(){
    if(adapter == null){
        adapter = new ArrayAdapter<String>(this,
                android.R.layout.simple_list_item_1, items);
        listView.setAdapter(adapter);

    } else{
        adapter.notifyDataSetChanged();
    }
}

@Override
public void onSensorChanged(final SensorEvent sensorEvent) {
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            if(sensorEvent.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                accelerometer = new Accelerometer(sensorEvent.values[0], sensorEvent.values[1], sensorEvent.values[2]);
            }
            database.setValue(accelerometer);
            handler.postDelayed(this, delay);
        }
    }, delay);
}

@Override
public void onAccuracyChanged(Sensor sensor, int i) {

}
}

public类MainActivity扩展AppCompatActivity实现SensorEventListener{
私人按钮接收按钮；
私有列表视图列表视图；
私有数据库参考数据库；
专用阵列适配器；
私人清单项目；
私人传感器管理器传感器管理器；
专用传感器；
私有处理程序=新处理程序（）；
私有最终整数延迟=5000；//以毫秒为单位
专用加速度计；
私人浮动价值；
私人价值；
私人价值；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
sensorManager=（sensorManager）getSystemService（传感器服务）；
SenAccelerator=sensorManager.getDefaultSensor（传感器类型\加速计）；
sensorManager.registerListener（此，传感器加速计，传感器管理器。传感器延迟正常）；
receiveButton=findViewById（R.id.receiveButton）；
listView=findViewById（R.id.listView）；
database=FirebaseDatabase.getInstance（）.getReference（“加速计”）；
items=newarraylist（）；
添加（“X值：+Float.toString（X值））；
添加（“Y值：+Float.toString（yValue））；
添加（“Z值：+Float.toString（zValue））；
updateUI（）；
receiveButton.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
database.addValueEventListener（新的ValueEventListener（）{
@凌驾
公共void onDataChange（DataSnapshot DataSnapshot）{
加速计加速度计=dataSnapshot.getValue（加速度计.class）；
xValue=加速计.xValue；
Y值=加速计。Y值；
zValue=加速计.zValue；
for（Iterator Iterator=items.Iterator（）；Iterator.hasNext（）；）{
iterator.next（）；
iterator.remove（）；
}
添加（“X值：+Float.toString（X值））；
添加（“Y值：+Float.toString（yValue））；
添加（“Z值：+Float.toString（zValue））；
}
@凌驾
已取消的公共void（DatabaseError DatabaseError）{
}
});
updateUI（）；
}
});
}
私有void updateUI（）{
if（适配器==null）{
适配器=新阵列适配器（此，
android.R.layout.simple_list_item_1，items）；
setAdapter（适配器）；
}否则{
adapter.notifyDataSetChanged（）；
}
}
@凌驾
传感器更改时的公共无效（最终传感器事件）{
handler.postDelayed（新的Runnable（）{
@凌驾
公开募捐{
if（sensorEvent.sensor.getType（）==sensor.TYPE\u加速计）{
加速计=新加速计（sensorEvent.values[0]，sensorEvent.values[1]，sensorEvent.values[2]）；
}
数据库设置值（加速计）；
handler.postDelayed（这个，delay）；
}
}，延误）；
}
@凌驾
精度更改时的公共无效（传感器，int i）{
}
}

---

提前谢谢

您应该使用此模式：

Handler handler = new Handler()
Runnable yourRunnable = new Runnable()
    {

        @Override
        public void run() {
            doYourAction();
            handler.postDelayed(yourRunnable, UPDATE_INTERVAL);
        }
    };

---

您可以尝试使用AsyncTask进行递归调用。比如：

public void checkAccelerometer() {
    final Handler handler = new Handler();
    new AsyncTask<Void, Void, Void>() {
        @Override
        protected void onPreExecute() {
            //Update UI if you want/need to
            super.onPreExecute();
        }

        @Override
        protected Void doInBackground(Void... voids) {
            //Do your thing
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            handler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    checkAccelerometer();
                }
            }, 5000);
            super.onPostExecute(aVoid);
        }
    }.execute();
}

公共无效检查加速计（）{
最终处理程序=新处理程序（）；
新建异步任务（）{
@凌驾
受保护的void onPreExecute（）{
//如果您想/需要，请更新UI
super.onPreExecute（）；
}
@凌驾
受保护的空位背景（空位…空位）{
//做你的事
返回null；
}
@凌驾
受保护的void onPostExecute（void避免）{
handler.postDelayed（新的Runnable（）{
@凌驾
公开募捐{
检查加速计（）；
}
}, 5000);
super.onPostExecute（避免）；
}
}.execute（）；
}

---

这将在后台线程中执行您的代码，并在5秒后调用自身以重复执行。如果您想找到一种方法来停止这个循环，您可以在开始时将所有内容都放入If语句中，然后检查是否存在可以在其他地方控制的布尔值。

我已经解决了这个问题，我必须将它放在oncreate方法中。因为如果你把它放在onSensorChanged中，它将在每次数据更改时执行。因此，如果在onSensorChanged之外执行数据，它将只执行一次，这将确保它不会每.5毫秒无限更新一次