Java执行程序模型，仅允许在实例化线程上运行任务

Question

I am writing a multithreaded application where I've got the situation that I have certain library-related methods that can only be run on the main-thread . Currently I am running a simple, self-written, solution that listens on a queue for tasks and then executes them serially as they come in.

This works so far although it gets ugly when I need return values etc. (Which I am currently solving the c-way by passing along datastructures with the tasks and then have a busy-loop checking if the structure has been written to on the site of the method that queues a task.

This is not really the cleanest solution, and while it works, I was hoping to find a better way of doing this..

Q : Is there anything in the JDK or in a single specialized library that does what I need? Or is there any programming pattern that addresses my needs in a clean and structured way?

Answer 1

A possible solution with CompletableFuture :

class Job<T> {
    private final Supplier<T> computation;
    private final CompletableFuture<T> future;

    Job(Supplier<T> computation, CompletableFuture<T> future) {
        this.future = future;
        this.computation = computation;
    }

    public Supplier<T> getComputation() {
        return computation;
    }

    public CompletableFuture<T> getFuture() {
        return future;
    }
}

public void client() {
    // on the client:
    CompletableFuture<String> future = new CompletableFuture<>();
    Supplier<String> computation = () -> "Here I am!";

    enqueue(new Job<>(computation, future));

    String resultString = future.get();
}

public <T> void server(Job<T> job) {
    // on the server; job is taken from the queue
    CompletableFuture<T> future = job.getFuture();
    future.complete(job.getComputation().get());
}

Here, on the client, future.get() will wait infinitely until the result is available. There is also another form:

future.get(1, TimeUnit.MINUTES)

would only wait for one minute and then return. This for can be used for polling.

Answer 2

Let your main thread plays role of an Executor:

static ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
public static void main(String... args) {
    // initialization...
    for (;;) {
        queue.take().run();
    }
}

Whenever you need to execute a task on the main thread, put it to the queue:

 queue.add(()->methodCall(1,2,3));

Answer 3

I'm not sure how you are time-slicing the main thread, but what you are saying is that you want to run some jobs using multiple threads and other jobs on the main thread sequentially.

Simplest answer would be to use two different work queues - one which is serviced by multiple threads and one which is serviced by only the main thread.

This would make both queues easier to understand and use.

Also, jobs running on either queue should implement an interface that requires them to expose a method that returns a reference to the resulting data - this might be the actual results or a file name or an input stream attached to the file containing the results.