lftimer.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 124 行

/*
 *   
 *
 * Copyright  1990-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

package javax.microedition.lcdui;

/**
 * Postponed task timer class is designed to postpone too frequent
 * requests.
 *
 * IMPL_NOTE: The methods cancel() and schedule() are to be as fast
 *   as possible, so method run() has simplified synchronization
 *   that enables cancelled task to be done on thread wake up.
 */
abstract class LFTimer implements Runnable {

    /** Invalidate timer states */
    final static int DEAD = -1;      // Timer thread is not started
    final static int ACTIVATED = -2; // Timer is activated to perform the task on wakeup
    final static int IDLE = -3;      // The task is not scheduled since
                                     //   timer is either done, or cancelled
    /**
     * State of the timer.
     * A positive value is one more timer state meaning
     * the time to wait to process inavlidate request.
     */
    private long state = DEAD;

    private final Object monitor;


    public LFTimer(Object monitor) {
        this.monitor = monitor;
    }

    /**
     * Cancel postponed task.
     * If task timer thread is started, it will be stopped on wake up.
     */
    void cancel() {
        synchronized(monitor) {
            if (state != DEAD) {
                state = IDLE;
            }
        }
    }

    /** Wait until postponed task can be done or cancelled */
    public void run() {
        while (true) {
            long sleepTime;
            synchronized(monitor) {
                if (state > 0) {
                    sleepTime = state;
                    state = ACTIVATED;
                } else {
                    // Terminate timer thread
                    state = DEAD;
                    return;
                }
            }
            try {
                Thread.sleep(sleepTime);
            } catch (InterruptedException ie) {
                // Consider interruption as wakeup
            }
            if (state == ACTIVATED){
                doTask();
            }
        }
    }

    /**
     * Schedule postponed task to be done later,
     * start timer thread if it has not been started yet.
     * @param time time to postpone the task for
     */
    void schedule(long time) {
        synchronized (monitor) {
            if (state == IDLE) {
                state = time;
            } else if (state == DEAD) {
                state = time;
                new Thread(this).start();
            }
        }
    }

    /** Process scheduled task. */
    private void doTask() {
        synchronized (monitor) {
            // While monitor was awaited, the state could be changed
            if (state == ACTIVATED) {
                perform();
                state = IDLE;
            }
        }
    }

    abstract protected void perform();
}