1

场景 - 我有一个基于计时器的事件线程，我通过发布请求发送数据（纬度和经度）。我有一个 onLocationChange 方法（我的类在 LocationListener 上实现），它在位置更改时被调用。它设置新的纬度和经度值，稍后应由计时器事件调用。

计时器事件不会在位置更改事件中获取最新的纬度和经度值。当计时器事件开始时，即使位置发生变化，它也不会调用 onlocationchange 方法。

这是计时器事件：

/** 此方法每 10 秒调用一次服务。*/

protected void timerMethod(CookieStore cookieStore, String url) {
    int delay = 1000; // delay for 1 sec.
    int period = 10000; // repeat every 10 sec.
    timer = new Timer();
    if (timer != null) {
        timer.scheduleAtFixedRate(new TimerTask() {
            public void run() {
                timerThread = new Thread() {
                    @Override
                    public void run() {

                        sendpostRequest();  // calling the post method
                    }
                };
                timerThread.start();

            }
        }, delay, period);
    }
}

这是位置更改事件：

/** 当位置改变时调用此方法。*/

public void onLocationChanged(Location location) {

    isLocationChanged = true;  // setting a boolean value which is checked while posting the request
    System.out.println();
    System.out.println("Location change:::longitude::::" + location.getLongitude() + "latiude::::"
            + location.getLatitude());

    latClient = location.getLatitude();
    longClient = location.getLongitude();

}
4

2 回答 2

0

处理程序是线程之间通信的一种方式，认为您可以使用它:)

于 2012-07-31T11:04:17.117 回答
0

我不确定我是否完全理解这个问题，但是这个解决方案效率低下，它创建了一堆线程，这些线程非常耗费资源。试试这样的东西。我在这个窗口中写了这一切并且没有测试，所以请确保你这样做，但鉴于你的问题描述，我认为这是正确的方向。确保在某个时候调用 TimerLooper.terminate() 否则你只会让这个线程流失。

private void startTimerThread() {
    mTimerLooper = new TimerLooper(new Handler() {
            @Override
            public void handleMessage() {
                onLocationChanged();
            }
        }, "timer-thread");
    mTimerLooper.start();
}

private class TimerLooper extends HandlerThread() {
    private static final int MSG_TERMINATE = 1;
    private static final int MSG_TIMER_EXPIRATION = 2;
    private Handler mCallback;
    private Handler mHandler;

    public TimerLooper(Handler callback, String name) {
        mCallback = callback;
    }

    @Override
    public void onLooperPrepared() {
        mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MSG_TERMINATE:
                        mHandler.removeMessages(MSG_TIMER_EXPIRATION);
                        getLooper().quit();
                        break;
                    case MSG_TIMER_EXPIRATION:
                        mCallback.sendEmptyMessage(0);
                        mHandler.sendEmptyMessageDelayed(
                                10000, MSG_TIMER_EXPIRATION);
                        break;
                }
        mHandler.sendEmptyMessageDelayed(10000, MSG_TIMER_EXPIRATION);
        super.onLooperPrepared();
    }

    public void terminate() {
        mHandler.sendEmptyMessage(MSG_TERMINATE);
    }
}
于 2012-07-31T18:30:49.253 回答