java concurrency Shared Data with Runnable vs Callable and local data

Question

First Case: Lets say you have a lot of tasks that all return a result of some kind, lets just call it `result' for now, and these all have to be stored in an arraylist. There's two options:

1) Create one arraylist in the main method and use runnables with access to the shared list and a synchronized add method

2) Create one arraylist in the main method and use callable to perform the task and return the result and let the main method add the Result to its list.

Are there any performance differences between the two, seeing as the runnable need synchronized acces, but the callables do not?

Then, to the Second Case: Lets now say each tasks generates a `small' arraylist, lets say less than 10 items per task. This again gives two options:

1) One arraylist in main and runnables with access to the shared list that add result items whenever generated.

2) One arrayList in main and callables> with each their own local arraylist that stores the Results untill the task is finished and then in main the addAll is used to add the found result.

Same question as before, what are the performance difference?

For the sake of clearity, performance both in terms of speed (some synchronization issues etc.) and in terms of memory(do the callables use a lot more memory due to the local small arraylist or is this small to neglible)?

depending on an implementation is a bad practice, your need to rely on interfaces instead — Nicolas Filotto, Jun 03 '16 at 10:37
It depends on your workload. If you have lots of small tasks, then you should concern about lock overhead. If the tasks take long time to finish, then the first consideration should be clean/readable code or else. — waltersu, Jun 03 '16 at 10:41

score 0 · Answer 1 · answered Jun 03 '16 at 16:19

For the First Case:

Option One: If we use Runnable tasks, then we cannot get anything returned from run() method. So I think this option will not suits your requirement.
Option Two: Callable As per my understanding of your requirement, Callable is good candidate. But there is a little change, We will create a list of Future and for every Callable task (which we will submit to executors) will add the Future result of this Callable(see below code for details) to this list. Then whenever we need the result of any task, we can get the result from the corresponding Future.

class MainTaskExecutor {

private static ExecutorService  exe = Executors.newCachedThreadPool();
private static List<Future<Result>> futureResults = new ArrayList<>();

public static void main(String[] args) throws ExecutionException, InterruptedException {
    Callable<Result> dummyTask = ()-> {
        System.out.println("Task is executed");
        Result dummyResult = new Result();
        return dummyResult;
    };

    //Submit a task
    submitTask(dummyTask);

    //Getting result of "0" index
    System.out.println(futureResults.get(0).get());
}

private static void submitTask(Callable<Result> task) {
    futureResults.add(exe.submit(task));
}

private static Result getResult(int taskNumber) throws ExecutionException, InterruptedException {
    return futureResults.get(taskNumber).get();
}

}

class Result {
    // data to be added
}

java concurrency Shared Data with Runnable vs Callable and local data

1 Answers1