Problem mit vielen Timer(-Events)

[Luk10]

Hallo,

In meinem Programm habe ich bis zu 400 Objekte, die alle einen Timer benötigen um individuell Werte zu verändern ...

Nun habe ich das mal mit den Swing-Timer versucht, also für Jedes Objekt, das erstellt wird auch einen Timer erstellt, es hat aber nicht geklappt, da die vielen Timer das Programm überansprucht haben und nicht richtig gearbeitet (mit viele Verzögerungen und solche Sachen) ...

Nun wollte ich mal Fragen ob jemand einen einfach und gute Lösung zu dem Problem hat ....

Danke, Luk

 

[Michael...]

Warum benötigten alle 400 Objekte einen eigenen Timer und wie sind diese getaktet?

 

[Luk10]

Wenn ich eins dieser Objekte erstelle, wird ein bestimmter int wert belegt, und ein Timer gestartet der im Takt von 8-10 Sekunden den int wert verringert ...

Bestimmte andere Faktoren erhöhen diesen Wert wieder (Nahrungsaufnahme/Verbrauch)

Das jedes Objekt zu einem anderen Zeitpunkt erstellt wird, muss ich für jedes einen individuellen Timer haben ....

So long, Luk

 

[Michael...]

Das jedes Objekt zu einem anderen Zeitpunkt erstellt wird, muss ich für jedes einen individuellen Timer haben ....

Kann man die nicht auf einen gemeinsamen Takt synchronisieren (z.B. 1 sec)? Dann würde ein Timer ausreichen, der über eine Liste der Objekte iteriert und je nach Bedarf für jedes Objekt den Wert erhöht, verringert oder sonst was macht.

 

[SlaterB]

oder ein Timer merkt sich für alle 400 Objekte die nächste Update-Zeit und schaut sich die dringendste an
und schläft dann 30ms oder 2000, je nachdem wieviel Zeit aktuell offen ist,

Achtung: alles unter ~30ms wird recht ungenau, aber auch bei sleep(5) sollte wenig schiefgehen,
schlimmstenfalls wird paar ms zu lang oder zu kurz geschlafen

vielleicht selber extra noch bisschen was drauf zählen, sonst kommt man je nie zur Pause,
wenn die nächsten angeforderten Zeiten 5, 8, 12, 25, 45, 70, 80, .. sind.
dann statt 5ms die Mindestzeit von z.B. 30 ms schlafen, dann die ersten 4 bearbeiten
(je nachdem was nach dem Aufwachen und neuen Uhrzeitvergleich aktuell erscheint),
dann wieder mindestens 30ms schlafen usw.

 

[Luk10]

SlaterB ich verstehe deinen Post nicht ganz ...
Wie soll sich das umsetzten lassen?

Ein kleines Beispiel zur Verdeutlichung:

Ein Objekt wird zum Zeitpunkt 0 erstellt, ein Timer soll nun (man gehe jetzt von gleicher Taktung für alle Objekte aus) jede 10 Sekung einen Wert verringern.
Ein weiteres Objekt wird zum Zeitpunkt 8s nach 0 erstellt und ich will wieder dass sofort alle 10 Sekunden nach erstellung (was dem starten eines neue Timers entspräche) einen Wert verringert wird ...

Kann mir jemand dazu einen (Pseudo)Code liefern, der dass im ersten beitrag angesprochene Problem umgeht/löst?

Danke

 

[SlaterB]

in den 400 Objekten bzw. in je einem Verwaltungsobjekt pro Objekt steht die Startzeit und das Intervall oder die nächste Aktualisierungszeit oder ähnliches,

du hast einen Timer bzw. einen ganz normalen Thread der mit Thread.sleep() schläft,
darin eine Schleife und wann immer nicht geschlafen wird, alle Objekte durchlaufen und schauen, ob aktuell was zu tun ist und ob geschlafen werden kann,
am Ende jedes Schleifendurchlaufs sind alle aktuellen Arbeiten erledigt und außerdem wurde nebenbei bestimmt, wie lange bis zum nächsten Schleifendurchlauf geschlafen wurde, nämlich indem alle offenen Intervalle angeschaut wurden,
die kleinste bestimmt die mögliche Schlafzeit

das ist gewiss nicht trivial, aber entweder du verstehst es aus dieser Erklärung so ungefähr und startest die Arbeit das zu programmieren (Fragen dazu ruhig stellen),
oder eben nicht, muss ja nicht so kompliziert sein,
obs wer komplett fertig programmiert? mit etwas Glück kommt wer vorbei, ja

 

[Luk10]

Okay ... Verstehe ich soweit schon nur folgendes:

Eine Sache verstehe ich noch nicht:

Wenn ich in die Schleife reingehe ... wie prüfe ich ob bei dem aktuellen Objekt etwas getan werden muss?...


Danke aber soweit für die beiden Ansätze ...

Luk

 

[faetzminator]

Du vergleichst die Startzeit mit der aktuellen, so solltest du den Wert berechnen können.

 

[Luk10]

Was meintst du denn mit "Startzeit"?
Soll das die Zeit sein nach welcher der Wert verringert werden soll?

Danke, Luk

 

[SlaterB]

es gilt ganz einfach 'mit Zeiten zu arbeiten',
das sagt doch schon alles, nimm das was du brauchst/ für richtig hälst

z.B. bei Erstellung des Objekte die aktuelle Systemzeit + den Wert 8 sec ablegen,
in der Schleife dann irgendwann später wieder aktuelle Systemzeit - Zeit im Objekt, dann kommt als Differenc 1 sec raus, oder 3,
was bedeutet 'nicht arbeiten sondern 7 bzw. 5 sec warten' oder es kommt irgendwann mal als Differen 8,01 sec raus,
das wäre ein günstiger Zeitpunkt zur Aktualisierung und das nächste Intervall vorzubereiten

einfache Schritte, wie Legosteine

 

[faetzminator]

Wenn z.B. ein Wert [c]x[/c] alle [c]y[/c] Sekunden um [c]z[/c] verringert werden soll, dann kann man das mit der Zeit, in welcher die Berechnungen beginnen sollen, berechnet werden:

long time = startTime - System.currentTimeMillis(); // startTime wurde anfänglich ebenfalls mit System.currentTimeMillis() initialisiert
x = x - time / 1000 / y * z;

 

[Luk10]

Danke ... ich bin noch nicht so vertraut mit Zeitrechnung ih Java ...

Wenn ich mir System.current.TimeMillis ausgeben lasse, bekomme ich die Zeit die Seit dem Programmstart vergangen ist, oder?

So long, Luk

 

[faetzminator]

Die vergangenen Millisekunden seit dem 1. Januar 1970 (UTC) Darum musst du auch die Anfangszeit davon abziehen (auch wenn es beim Programmstart beginnen soll). Sieh doch dafür einfach in die API: System (Java Platform SE 6)

 

[Luk10]

Wenn z.B. ein Wert [c]x[/c] alle [c]y[/c] Sekunden um [c]z[/c] verringert werden soll, dann kann man das mit der Zeit, in welcher die Berechnungen beginnen sollen, berechnet werden:

long time = startTime - System.currentTimeMillis(); // startTime wurde anfänglich ebenfalls mit System.currentTimeMillis() initialisiert
x = x - time / 1000 / y * z;

Aber hier ziehst du doch die aktuelle Zeit von der startZeit ab ... was bedeuten würde, dass ein Negativer Wert rauskommt ... (Die System.currenTimeMillis nimmt ja immer weiter zu!

Gott macht mich das verrückt mit dieser dämlichen Zeitrechnerei
Danke für eure Geduld mit mir :toll:

Luk

 

[Cola_Colin]

Ich glaub da hat er sich vertan und du musst startTime und System.currentTimeMillis() vertauschen.
Sonst wird x größer, nicht kleiner.

Soweit ich das jetzt überblickt habe.

 

[Marco13]

Klang ganz interessant, hab mal ein bißchen rumprobiert... Im Endeffekt ist's auf das rausgelaufen, was SlaterB schon angedeutet hat (so ähnlich zumindest) : Eine Möglichkeit ist, sich für jeden Task zu merken, wann er (in bezug auf die "Globale Zeit", z.B. currentTimeMillis) das nächste mal ausgeführt werden muss. Die Tasks werden dann in eine Liste eingefügt - und zwar sortiert nach der Zeit, wann sie das nächste mal ausgeführt werden müssen. So steht am Anfang der Liste immer das Element, das als nächstes ausgeführt werden muss. Der Haupt-Thread holt sich dieses Element, schaut, wann es ausgeführt werden muss, und wartet falls nötig bis dieser Zeitpunkt erreicht ist. Wenn das Element abgearbeitet ist, wird es vom Anfang der Liste entfernt, der nächste Ausführungzeitpunkt bestimmt, und es dann wieder neu (wieder sortiert) in die Liste eingefügt. (Vielleicht landet es dann wieder am Anfang, vielleicht auch weiter hinten).

Interessant wird's halt bei Details, wie wenn auf einmal 100 Elemente gleichzeitig ausgeführt werden sollen, oder wenn der Haupt-Thread gerade auf das erste Element wartet, das erst in 10 Skeunden ausgeführt werden muss, und ihm dann jemand mit einen neuen Element dazwischenfunken will, das schon in 9 Skeunden ausgeführt werden müßte ... da muss man ein bißchen aufpassen, aber vom Prinzip her könnte das gar nicht soooo aufwändig sein.


DAS IST NUR EIN HIN-GEHACKTER TEST - nicht hauen

import java.util.*;

class GlobalTime
{
    private static long startMS = 0;

    public static void init()
    {
        startMS = System.currentTimeMillis();
    }

    public static long get()
    {
        return System.currentTimeMillis() - startMS;
    }
}


class Task
{
    private static int currentID = 0;

    private int id = 0;
    private long intervalMS = 0;
    private long nextTimeMS = 0;

    private long previousTimeMS = -1;

    public Task(long intervalMS)
    {
        id = Task.currentID;
        Task.currentID++;

        this.intervalMS = intervalMS;
    }


    public void performAction()
    {
        System.out.println("performAction at time "+GlobalTime.get()+": "+this);
        if (previousTimeMS != -1)
        {
            long diff = GlobalTime.get() - previousTimeMS;
            System.out.println("Difference was "+diff+", should be "+intervalMS);
        }
        previousTimeMS = GlobalTime.get();

    }

    public String toString()
    {
        return "Task "+id+" with interval "+intervalMS +" to be executed next at "+nextTimeMS;
    }

    public void setNextTimeMS(long nextTimeMS)
    {
        this.nextTimeMS = nextTimeMS;
    }

    public long getNextTimeMS()
    {
        return nextTimeMS;
    }

    public long getIntervalMS()
    {
        return intervalMS;
    }
}



class Scheduler implements Runnable
{
    private LinkedList<Task> tasks = new LinkedList<Task>();

    public void schedule(Task task)
    {
        task.setNextTimeMS(GlobalTime.get()+task.getIntervalMS());
        synchronized (tasks)
        {
            sortedInsert(task);
            tasks.notifyAll();
        }
    }

    private void sortedInsert(Task task)
    {
        int index = 0;
        for (Task t : tasks)
        {
            if (t.getNextTimeMS() > task.getNextTimeMS())
            {
                break;
            }
            index++;
        }
        tasks.add(index, task);
    }

    public void run()
    {
        while (true)
        {
            while (tasks.isEmpty())
            {
                try
                {
                    System.out.println("Scheduler waiting for objects...");
                    synchronized (tasks)
                    {
                        tasks.wait();
                    }
                }
                catch (InterruptedException e)
                {
                    Thread.currentThread().interrupt();
                    return;
                }
            }

            Task task = null;
            synchronized (tasks)
            {
                task = tasks.removeFirst();
            }

            long waitTime = task.getNextTimeMS() - GlobalTime.get();
            if (waitTime > 0)
            {
                sleep(waitTime);
            }
            task.performAction();
            task.setNextTimeMS(task.getNextTimeMS()+task.getIntervalMS());

            synchronized (tasks)
            {
                sortedInsert(task);
            }

        }
    }


    private static void sleep(long ms)
    {
        try
        {
            Thread.sleep(ms);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }

}



class ScheduleTest
{
    public static void main(String args[])
    {
        final Scheduler scheduler = new Scheduler();
        Thread schedulerThread = new Thread(scheduler);
        schedulerThread.start();

        Thread fillThread = new Thread(new Runnable()
        {
            public void run()
            {
                GlobalTime.init();
                sleep(500);
                scheduler.schedule(new Task(1000));
                sleep(250);
                scheduler.schedule(new Task(1000));
                sleep( 50);
                scheduler.schedule(new Task(200));
            }

        });
        fillThread.start();
    }

    private static void sleep(long ms)
    {
        try
        {
            Thread.sleep(ms);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }

}

 

[faetzminator]

Aber hier ziehst du doch die aktuelle Zeit von der startZeit ab ... was bedeuten würde, dass ein Negativer Wert rauskommt ...

Richtig, da habe ich mich vertan - also hast du das Prinzip verstanden :toll: