Android视图更新程序线程允许视图仅更新一次，每毫秒仅按需更新

Question

我有一个我想等待事件的线程。当通知此线程时，我希望它醒来，并且它比Refresh_time更长，那么它将带有呼叫引进的视图无效。否则，它将在下一个refresh_time上落入时间的时间。同时，如果其他事件试图将其通知绘制，则应设置一些标志，以便在下一个RefResh_Time再次通过后再次重新绘制。否则，它将无限期等待直到下一个通知（或当然要停止，但为简单起见）。

我试图在等待和通知的同步锁中开发它，似乎我不能只使用它。对于C 而言，想到了带有超时的WaitForsingLeoBject，但是在Java中，我还没有机会做类似的事情。最适合这个问题的一种用途是什么？

如果我在运行更新时收到100次通知，我应该将它们视为单个通知，并仅添加一个无效，在下一个通知之后掉落refresh_time milliseconds。换句话说。更新不能错过。

这是一些不完整的代码。我怎么能完成？

public class ViewInvalidator extends Thread {
private View m_view;
Object lock = new Object();
boolean ready = false;
long m_refreshTimeMilliseconds;
boolean m_threadRequestedToStop = false;
public ViewInvalidator(View view, long refreshTimeMilliseconds) {
    m_view = view;
    m_refreshTimeMilliseconds = refreshTimeMilliseconds;
}
public void postInvalidate() {
    synchronized(lock) {
        ready = true;
        lock.notifyAll();
    }
}
public void stopThread() {
    synchronized (lock) {
        while(!ready)
            lock.notifyAll();
    }
}
@Override
public void run() {
    long lastPostInvalidate = System.currentTimeMillis(), timeSince;
    while(true) {
        if (this.m_threadRequestedToStop)
            break;
        try {
            synchronized (lock) {
                while (!ready)
                    lock.wait();
            }
        } catch(InterruptedException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
            break;
        }
        // someone just woke us up.  Check if it was a request to stop.  If it was, stop.
        if (this.m_threadRequestedToStop)
            break;
        // if less time than our refresh time, sleep for the difference, then invalidate.  Otherwise just invalidate.
        timeSince = System.currentTimeMillis() - lastPostInvalidate;
        if(timeSince < m_refreshTimeMilliseconds)
            try {
                Thread.sleep(m_refreshTimeMilliseconds - timeSince);
            } catch(InterruptedException e) {}
        m_view.postInvalidate();
    }
}

非常感谢，Mike

Answer 1

long lastPostInvalidate;
bool running;
bool valid;
public void f(){
if(running)if(!valid)synchronized(valid){valid=true;}
else {
running = true;
while(func()){};
running = false;
}
private bool func() {
synchronized (valid){valid = false;}
synchronized (lastPostInvalidate) {
long next = System.currentTimeMillis();
long x = next - timeSincelastPostInvalidate;
x = m_refreshTimeMilliseconds-x;
if(x>0)sleep(x);
m_view.postInvalidate();
timeSincelastPostInvalidate = next;
}return valid;
}

忘记了使用条件。实际上应该看起来像这样。也就是说，这样做的话，如果您期望经常更新更新，则可能会锁定您的更新线程，如果您还将这些线程用于其他事物，那将很重要。如果您期望经常进行更新，则不妨按照您计划的计划使用该线程，但没有停用该线程，并且是否需要运行是否需要检查每个间隔。