Class ThreadSync

src/main/java/field/app/ThreadSync.java:27–579

Yield with (an unbounded but recycled number of) threads. We used to use a wonderful homemade byte-code rewriting based trick to implement 'yield' for annotated methods. This trick takes a very different path, it's less space and time efficient (the context switch into the method is much slower

 * TODO: finish making _r = wrap( () => {}) work
 */
public class ThreadSync {
    static public final boolean enabled = Options.dict()
            .isTrue(new Dict.Prop("threaded"), false);
    static private final ExecutorService executor = Executors.newCachedThreadPool();
    static public Object NULL = new Object();
    public static ThreadLocal<Fiber> fiber = new ThreadLocal<>();
    static ThreadLocal<ThreadSync> threadingModel = new ThreadLocal<>();
    static private Map<Thread, ThreadSync> models = new MapMaker().weakKeys()
            .makeMap();
    static public Thread mainThread;
    Set<Fiber> live = new LinkedHashSet<Fiber>();

    public Fiber currentFiber;

    // this should be getThreadingModelForCurrentThread();
    protected ThreadSync() {
            mainThread = Thread.currentThread();
    }

    static public ThreadSync get() {
        return models.computeIfAbsent(Thread.currentThread(), k -> new ThreadSync());
    }

    static public <K> Supplier<K> input(Iterator<K> a) {
        return () -> {
            if (a.hasNext()) {
                K k = a.next();
                if (k == null) throw new Stop("input returned null");
                return a.next();
            }
            throw new Stop();
        };
    }

    static public <T> T callInMainThreadAndWait(Callable<T> c) throws Exception {
        if (Thread.currentThread() == RunLoop.main.mainThread) {
            System.out.println("||||||||||||||||||||||||||||||| already main thread");
            return c.call();
        } else {

            System.out.println(" current thread :"+Thread.currentThread()+" "+RunLoop.main.mainThread);

            CompletableFuture<T> f = new CompletableFuture<>();
            System.out.println("||||||||||||||||||||||||||||||| call once ");
            RunLoop.main.once(() -> {
                try {
                    f.complete(c.call());
                } catch (Throwable t) {
                    f.completeExceptionally(t);
                }
            });

            // should be rejoin?
            System.out.println("||||||||||||||||||||||||||||||| begin wait ");
            while (!f.isDone()) {
                System.out.println("||||||||||||||||||||||||||||||| yield to main loop");
                ThreadSync.yield(true);
                System.out.println("||||||||||||||||||||||||||||||| back from main loop");