source: java/main/src/main/java/com/framsticks/util/dispatching/Thread.java @ 85

package com.framsticks.util.dispatching;

import org.apache.log4j.Logger;

import java.util.LinkedList;
import java.util.ListIterator;
import com.framsticks.util.dispatching.RunAt;

/**
 * @author Piotr Sniegowski
 */
public class Thread<C> implements Dispatcher<C> {

        private static final Logger log = Logger.getLogger(Thread.class.getName());

        protected final java.lang.Thread thread;

        private final LinkedList<Task<? extends C>> queue = new LinkedList<>();

        public Thread() {
                thread = new java.lang.Thread(new java.lang.Runnable() {
                        @Override
                        public void run() {
                                Thread.this.routine();
                        }
                });
        }

        public Thread(String s) {
                this();
                thread.setName(s);
                // thread.start();
        }

        public Thread(String s, java.lang.Thread thread) {
                this.thread = thread;
                thread.setName(s);
        }

        public Thread<C> start() {
                thread.start();
                return this;
        }

        @Override
        public final boolean isActive() {
                return thread.equals(java.lang.Thread.currentThread());
        }

        protected void routine() {
                while (!java.lang.Thread.interrupted()) {
                        Task<? extends C> task;
                        synchronized (queue) {
                                if (queue.isEmpty()) {
                                        try {
                                                queue.wait();
                                        } catch (InterruptedException ignored) {
                                                break;
                                        }
                                        continue;
                                }
                                task = queue.peekFirst();
                                assert task != null;
                                if (task.moment > System.currentTimeMillis()) {
                                        try {
                                                queue.wait(task.moment - System.currentTimeMillis());
                                        } catch (InterruptedException ignored) {
                                                continue;
                                        }
                                        continue;
                                }
                                queue.pollFirst();
                        }
                        try {
                                task.run();
                        } catch (Exception e) {
                                log.error("error in thread: " + e);
                                e.printStackTrace();
                        }
                }
        }

        protected void enqueueTask(Task<? extends C> task) {
                synchronized (queue) {
                        ListIterator<Task<? extends C>> i = queue.listIterator();
                        while (i.hasNext()) {
                                Task<? extends C> t = i.next();
                                if (t.getMoment() > task.getMoment()) {
                                        i.previous();
                                        i.add(task);
                                        task = null;
                                        break;
                                }
                        }
                        if (task != null) {
                                queue.add(task);
                        }

                        /*
                        Iterator<Task> j = queue.iterator();
                        Task prev = null;
                        while (j.hasNext()) {
                                Task next = j.next();
                                assert (prev == null) || prev.getMoment() <= next.getMoment();
                                prev = next;
                        }
                        */
                        queue.notify();
                }
        }

        @Override
        public void invokeLater(final RunAt<? extends C> runnable) {
                if (!(runnable instanceof Task)) {
                        enqueueTask(new Task<C>() {
                                @Override
                                public void run() {
                                        runnable.run();
                                }
                        });
                        return;
                }
                enqueueTask((Task<? extends C>) runnable);
        }

        public void interrupt() {
                thread.interrupt();
        }

        public void join() throws InterruptedException {
                thread.join();
        }

        public void setName(String name) {
                thread.setName(name);

        }

        public static boolean interrupted() {
                return java.lang.Thread.interrupted();
        }
}