Neko und haxe.Timer.delayed ()

Question

Wie jede Haxe Entwickler weiß, Sie haxe.Timer.delayed() nutzen könnte Funktionsaufruf für einige Zeit zu verzögern. Aber diese Funktion gibt es gar nicht für Neko. Gibt es eine Möglichkeit die gleichen Ergebnisse?

zu erreichen

Answer 1

Haben Sie es zu überprüfen, zuerst aber

function delayed(f, time) {
   neko.vm.Thread.create(function() {
       neko.Sys.sleep(time);
       f();
   });
}

könnte die nächste Sache möglich sein. Der einzige Nachteil ist, dass die Anwendung multi-threaded wird, die zu ernsthaften Problemen führen könnte.

Answer 2

Ich dachte über das Problem und ich denke, der beste Weg, um Ihre eigene Timer-Klasse für Neko zu erstellen. Ich habe eine Timer-Klasse für Sie:

NekoTimer.hx

package;
import neko.Sys;

    class NekoTimer 
    {
    private static var threadActive:Bool = false;
    private static var timersList:Array<TimerInfo> = new Array<TimerInfo>();
    private static var timerInterval:Float = 0.1;

    public static function addTimer(interval:Int, callMethod:Void->Void):Int
    {
        //setup timer thread if not yet active
        if (!threadActive) setupTimerThread();

        //add the given timer
        return timersList.push(new TimerInfo(interval, callMethod, Sys.time() * 1000)) - 1;
    }

    public static function delTimer(id:Int):Void
    {
        timersList.splice(id, 1);
    }

    private static function setupTimerThread():Void
    {
        threadActive = true;
        neko.vm.Thread.create(function() {
            while (true) {
                Sys.sleep(timerInterval);
                for (timer in timersList) {
                    if (Sys.time() * 1000 - timer.lastCallTimestamp >= timer.interval) {
                        timer.callMethod();
                        timer.lastCallTimestamp = Sys.time() * 1000;
                    }
                }
            }
        });
    }
}

private class TimerInfo
{
    public var interval:Int;
    public var callMethod:Void->Void;
    public var lastCallTimestamp:Float;

    public function new(interval:Int, callMethod:Void->Void, lastCallTimestamp:Float) {
        this.interval = interval;
        this.callMethod = callMethod;
        this.lastCallTimestamp = lastCallTimestamp;
    }
}

Nennen Sie es wie folgt aus:

package ;

import neko.Lib;

class Main 
{
    private var timerId:Int;

    public function new()
    {
        trace("setting up timer...");
        timerId = NekoTimer.addTimer(5000, timerCallback);
        trace(timerId);

        //idle main app
        while (true) { }
    }

    private function timerCallback():Void
    {
        trace("it's now 5 seconds later");
        NekoTimer.delTimer(timerId);
        trace("removed timer");
    }

    //neko constructor
    static function main() 
    {
        new Main();
    }
}

Ich hoffe, das hilft.

Hinweis: dieses eine Genauigkeit von 100 ms hat. Sie können dies durch Erhöhung der TimerInterval Einstellung zu verringern.

Answer 3

ich verwenden, um die Klasse als gut, und ich fand ein Problem. Da nicht vollständig in Echtzeit ist, schläft es das Intervall, ruft die Funktion und schläft wieder das Intervall. Also, je nachdem, wie lange die Funktion, die Sie dauerte laufen, es tickt langsamer oder schneller.

ich gelöst habe es durch die Linie ersetzt 39 wie folgt:

//timer.lastCallTimestamp = Sys.time() * 1000;
timer.lastCallTimestamp = timer.lastCallTimestamp + timer.interval;

Answer 4

Ja, ich weiß nichts außer dem, was Sie in Ihrer ersten Antwort erwähnen. Unter Linux können Sie SIGALARM verwenden - aber das ist nicht trivial, 100% reinen C-Code sieht, und muss mit großer Sorgfalt behandelt werden, um die VM zu vermeiden Absturz

.