com.fireflysource.common.actor.BlockingTask Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of firefly-common Show documentation
There is a newer version: 5.0.2
package com.fireflysource.common.actor;

import com.fireflysource.common.func.Callback;
import com.fireflysource.common.slf4j.LazyLogger;
import com.fireflysource.common.sys.Result;
import com.fireflysource.common.sys.SystemLogger;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ForkJoinPool;

import static com.fireflysource.common.sys.Result.runCaching;

public class BlockingTask implements ForkJoinPool.ManagedBlocker {

    private static final LazyLogger log = SystemLogger.create(BlockingTask.class);

    private final Callable callable;
    private final Callable> tryCallable;
    private T result;
    private boolean done = false;

    public BlockingTask(Callable callable, Callable> tryCallable) {
        this.callable = callable;
        this.tryCallable = tryCallable;
    }

    @Override
    public boolean block() throws InterruptedException {
        try {
            result = callable.call();
        } catch (Exception e) {
            log.error("run blocking task exception.", e);
        }
        done = true;
        return true;
    }

    @Override
    public boolean isReleasable() {
        try {
            Result r = tryCallable.call();
            done = r.isSuccess();
            if (done) {
                result = r.getValue();
            }
        } catch (Exception e) {
            done = false;
        }
        return done;
    }

    public static void runBlockingTask(Callback callback) {
        runBlockingTask(() -> {
            callback.call();
            return null;
        });
    }

    public static  Result runBlockingTask(Callable callable) {
        return runBlockingTask(callable, null);
    }

    public static  Result runBlockingTask(Callable callable, Callable> tryCallable) {
        return runCaching(() -> {
            BlockingTask task = new BlockingTask<>(callable, tryCallable);
            ForkJoinPool.managedBlock(task);
            return task.result;
        });
    }

    public static void sleep(long millisecond) {
        runBlockingTask(() -> Thread.sleep(millisecond));
    }

    public static  T blockingTake(final BlockingQueue queue) {
        Result result = runBlockingTask(queue::take, () -> {
            T t = queue.poll();
            return new Result<>(t != null, t, null);
        });
        return result.getValue();
    }
}