421 lines
11 KiB
Java
421 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2017, 7u83 <7u83@mail.ru>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
package sesim;
|
|
|
|
//import static com.sun.org.apache.xalan.internal.lib.ExsltDatetime.date;
|
|
import gui.Globals;
|
|
import java.text.DateFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Comparator;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.SortedMap;
|
|
import java.util.SortedSet;
|
|
import java.util.TreeMap;
|
|
import java.util.TreeSet;
|
|
import java.util.concurrent.ConcurrentLinkedQueue;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
/**
|
|
*
|
|
* @author 7u83 <7u83@mail.ru>
|
|
*/
|
|
public class Scheduler extends Thread {
|
|
|
|
private double acceleration = 1.0;
|
|
|
|
public void setAcceleration(double val) {
|
|
|
|
this.acceleration = val;
|
|
synchronized (this) {
|
|
this.notify();
|
|
}
|
|
}
|
|
|
|
public double getAcceleration() {
|
|
|
|
return this.acceleration;
|
|
}
|
|
|
|
private final SortedMap<Long, SortedSet<TimerTaskDef>> event_queue = new TreeMap<>();
|
|
|
|
public interface TimerTaskRunner {
|
|
|
|
long timerTask();
|
|
|
|
long getID();
|
|
}
|
|
|
|
private boolean terminate = false;
|
|
|
|
/**
|
|
* Terminate the scheduler
|
|
*/
|
|
public void terminate() {
|
|
terminate = true;
|
|
synchronized (event_queue) {
|
|
event_queue.notifyAll();
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void start() {
|
|
if (this.isAlive()) {
|
|
return;
|
|
}
|
|
this.initScheduler();
|
|
super.start();
|
|
|
|
}
|
|
|
|
private class ObjectComparator implements Comparator<Object> {
|
|
|
|
@Override
|
|
public int compare(Object o1, Object o2) {
|
|
|
|
return (((TimerTaskRunner) o1).getID() - ((TimerTaskRunner) o2).getID()) < 0 ? -1 : 1;
|
|
//return System.identityHashCode(o1) - System.identityHashCode(o2);
|
|
}
|
|
}
|
|
|
|
long last_time_millis = System.currentTimeMillis();
|
|
double current_time_millis = 0.0;
|
|
|
|
Clock clock;
|
|
|
|
long last_nanos = System.nanoTime();
|
|
double current_nanos = 0;
|
|
|
|
/**
|
|
*
|
|
* @return
|
|
*/
|
|
public long currentTimeMillis1() {
|
|
|
|
long cur = System.nanoTime();
|
|
long diff = cur - last_nanos;
|
|
last_nanos = cur;
|
|
|
|
if (pause) {
|
|
return (long) this.current_time_millis;
|
|
}
|
|
|
|
// this.cur_nano += (((double)diff_nano)/1000000.0)*this.acceleration;
|
|
// return (long)(cur_nano/1000000.0);
|
|
this.current_nanos += (double) diff * (double) this.acceleration;
|
|
|
|
// this.current_time_millis += ((double) diff) * this.acceleration;
|
|
this.current_time_millis = this.current_nanos / 1000000.0;
|
|
|
|
return (long) this.current_time_millis;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return
|
|
*/
|
|
public long currentTimeMillis1_old() {
|
|
|
|
long cur_nano = System.nanoTime();
|
|
long diff_nano = cur_nano - last_nanos;
|
|
last_nanos = cur_nano;
|
|
|
|
long cur = System.currentTimeMillis();
|
|
|
|
long diff = (cur - last_time_millis);
|
|
|
|
//System.out.printf("Diff Nanos: %d Diff Millis %d, ND: %d\n", diff_nano, diff, diff_nano/1000000);
|
|
last_time_millis = cur;
|
|
|
|
// last_time_millis += diff;
|
|
//if (diff == 0) {
|
|
// diff++;
|
|
// }
|
|
if (pause) {
|
|
return (long) this.current_time_millis;
|
|
}
|
|
|
|
// this.cur_nano += (((double)diff_nano)/1000000.0)*this.acceleration;
|
|
// return (long)(cur_nano/1000000.0);
|
|
double fac = (((double) diff) + 10.0) * this.acceleration;
|
|
System.out.printf("Difdif: %f %f\n", fac, this.acceleration);
|
|
this.current_time_millis += ((double) diff) * this.acceleration;
|
|
return (long) this.current_time_millis;
|
|
}
|
|
|
|
public long currentTimeMillis() {
|
|
// return (long)(cur_nano/1000000.0);
|
|
return (long) this.current_time_millis;
|
|
}
|
|
|
|
static public String formatTimeMillis(long t) {
|
|
Date date = new Date(t);
|
|
DateFormat formatter = new SimpleDateFormat("HH:mm:ss");
|
|
String dateFormatted = formatter.format(date);
|
|
|
|
long seconds = (t / 1000) % 60;
|
|
long minutes = (t / 1000 / 60) % 60;
|
|
long hours = (t / 1000) / (60 * 60);
|
|
return String.format("%02d:%02d:%02d", hours, minutes, seconds);
|
|
|
|
}
|
|
|
|
AtomicInteger nextTimerTask = new AtomicInteger(0);
|
|
|
|
public class TimerTaskDef implements Comparable {
|
|
|
|
TimerTaskRunner taskRunner;
|
|
long curevtime;
|
|
long newevtime;
|
|
int id;
|
|
|
|
TimerTaskDef(TimerTaskRunner e, long t) {
|
|
taskRunner = e;
|
|
newevtime = t;
|
|
id = nextTimerTask.getAndAdd(1);
|
|
|
|
}
|
|
|
|
@Override
|
|
public int compareTo(Object o) {
|
|
return ((TimerTaskDef) o).id - this.id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//LinkedList<TimerTaskDef> set_tasks = new LinkedList<>();
|
|
ConcurrentLinkedQueue<TimerTaskDef> set_tasks = new ConcurrentLinkedQueue<>();
|
|
|
|
/**
|
|
*
|
|
* @param e
|
|
* @param time
|
|
* @return The TimerTask created
|
|
*/
|
|
public TimerTaskDef startTimerTask(TimerTaskRunner e, long time) {
|
|
|
|
long evtime = time + currentTimeMillis();
|
|
|
|
TimerTaskDef task = new TimerTaskDef(e, evtime);
|
|
set_tasks.add(task);
|
|
|
|
synchronized (this) {
|
|
notify();
|
|
}
|
|
return task;
|
|
}
|
|
|
|
public void XXXrescheduleTimerTask(TimerTaskDef task, long time) {
|
|
long evtime = time + currentTimeMillis();
|
|
set_tasks.add(task);
|
|
|
|
synchronized (this) {
|
|
notify();
|
|
}
|
|
}
|
|
|
|
private boolean pause = false;
|
|
|
|
public void pause() {
|
|
setPause(!pause);
|
|
|
|
}
|
|
|
|
public void setPause(boolean val) {
|
|
pause = val;
|
|
synchronized (this) {
|
|
this.notify();
|
|
}
|
|
|
|
}
|
|
|
|
public boolean getPause() {
|
|
return pause;
|
|
}
|
|
|
|
public long fireEvent(TimerTaskRunner e) {
|
|
return e.timerTask();
|
|
}
|
|
|
|
// HashMap<TimerTaskDef, Long> tasks = new HashMap<>();
|
|
private boolean addTimerTask(TimerTaskDef e) {
|
|
|
|
// long evtime = time + currentTimeMillis();
|
|
SortedSet<TimerTaskDef> s = event_queue.get(e.newevtime);
|
|
if (s == null) {
|
|
s = new TreeSet<>();
|
|
event_queue.put(e.newevtime, s);
|
|
}
|
|
|
|
e.curevtime = e.newevtime;
|
|
|
|
// tasks.put(e, e.evtime);
|
|
return s.add(e);
|
|
}
|
|
|
|
private final LinkedList<TimerTaskRunner> cancel_queue = new LinkedList();
|
|
|
|
public void cancelTimerTask(TimerTaskRunner e) {
|
|
cancel_queue.add(e);
|
|
}
|
|
|
|
private void cancelMy(TimerTaskDef e) {
|
|
|
|
// Long evtime = tasks.get(e.curevtime);
|
|
// if (evtime == null) {
|
|
// return;
|
|
// }
|
|
SortedSet<TimerTaskDef> s = event_queue.get(e.curevtime);
|
|
if (s == null) {
|
|
|
|
return;
|
|
}
|
|
|
|
Boolean rc = s.remove(e);
|
|
|
|
if (s.isEmpty()) {
|
|
|
|
event_queue.remove(e.curevtime);
|
|
}
|
|
|
|
}
|
|
|
|
public long runEvents() {
|
|
synchronized (event_queue) {
|
|
|
|
if (event_queue.isEmpty()) {
|
|
return -1;
|
|
}
|
|
|
|
long t = event_queue.firstKey();
|
|
long ct = currentTimeMillis1();
|
|
|
|
// ct = t;
|
|
if (t > ct) {
|
|
//if ((long) diff > 0) {
|
|
// System.out.printf("Leave Event Queue in run events %d\n", Thread.currentThread().getId());
|
|
// System.out.printf("Sleeping somewat %d\n", (long) (0.5 + (t - this.currentTimeMillis()) / this.acceleration));
|
|
// return (long) diff;
|
|
return (long) (((double) t - this.currentTimeMillis()) / this.acceleration);
|
|
}
|
|
|
|
if (t < ct) {
|
|
// System.out.printf("Time is overslipping: %d\n",ct-t);
|
|
this.current_time_millis = t;
|
|
this.current_nanos = this.current_time_millis * 1000000.0;
|
|
|
|
}
|
|
|
|
// if (t <= ct) {
|
|
SortedSet s = event_queue.get(t);
|
|
Object rc = event_queue.remove(t);
|
|
|
|
if (s.size() > 1) {
|
|
//System.out.printf("Events in a row: %d\n", s.size());
|
|
}
|
|
|
|
Iterator<TimerTaskDef> it = s.iterator();
|
|
while (it.hasNext()) {
|
|
TimerTaskDef e = it.next();
|
|
// if (s.size() > 1) {
|
|
// System.out.printf("Sicku: %d %d\n", e.id, e.curevtime);
|
|
// }
|
|
|
|
long next_t = this.fireEvent(e.taskRunner);
|
|
e.newevtime = next_t + t;
|
|
this.addTimerTask(e);
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
class EmptyCtr implements TimerTaskRunner {
|
|
|
|
@Override
|
|
public long timerTask() {
|
|
// System.out.printf("Current best brice %f\n", Globals.se.getBestPrice());
|
|
return 1000;
|
|
}
|
|
|
|
@Override
|
|
public long getID() {
|
|
return 999999999999999999L;
|
|
// throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
|
|
}
|
|
|
|
}
|
|
|
|
void initScheduler() {
|
|
current_time_millis = 0.0;
|
|
this.startTimerTask(new EmptyCtr(), 0);
|
|
terminate = false;
|
|
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
|
|
while (!terminate) {
|
|
|
|
while (!set_tasks.isEmpty()) {
|
|
TimerTaskDef td = set_tasks.poll();
|
|
this.cancelMy(td);
|
|
this.addTimerTask(td);
|
|
|
|
}
|
|
|
|
long wtime = runEvents();
|
|
|
|
if (wtime == 0) {
|
|
continue;
|
|
}
|
|
|
|
synchronized (this) {
|
|
try {
|
|
// System.out.printf("My WTIME %d\n", wtime);
|
|
if (wtime != -1 && !pause) {
|
|
wait(wtime);
|
|
} else {
|
|
wait();
|
|
}
|
|
} catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
this.event_queue.clear();
|
|
|
|
}
|
|
|
|
}
|