Java: Using ExecutorService for concurrency

Question

I want to execute some tasks parallel so I was searching for multithreading in Java and I found this class, ExecutorService. I tried with simple example but I am not sure whether it is running in parallel.

long startTime = System.currentTimeMillis();
List<Callable<String>> callables = new ArrayList<Callable<String>>();
ExecutorService executor = Executors.newCachedThreadPool();
callables.add(new Callable<String>() {
        public String call() {
            for (int i=0; i<100000; i++) {
                System.out.println("i "+i);
            }
            return "Task 1";
        }
    }
);
        
callables.add(new Callable<String>() {
        public String call() {
            for (int j=0; j<100000; j++) {
                System.out.println("j "+j);
            }
            return "Task 2";
        }
    }
);
        
callables.add(new Callable<String>() {
     public String call() {
          for (int k=0; k<100000; k++) {
              System.out.println("k "+k);
          } 
          return "Task 3";
      }
  }
);
try {
    List<Future<String>> futureLst = executor.invokeAll(callables);
    for (Future future : futureLst) {
        try {
            System.out.println(future.get());
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
executor.shutdown();
System.out.println("Time Taken - "+ (System.currentTimeMillis() - startTime));

The above code works fine as expected and prints the count and returns the string. The time taken for the above program to execute is "3229" milliseconds.

I rewrote the above program as below,

long startTime = System.currentTimeMillis();
for (int i=0; i<100000; i++) {
    System.out.println("i "+i);
}
for (int j=0; j<100000; j++) {
    System.out.println("j "+j);
}
for (int k=0; k<100000; k++) {
    System.out.println("k "+k);
}
System.out.println("Time Taken - "+ (System.currentTimeMillis() - startTime));

The time taken for this program is "3104" milliseconds which is lesser than the one coded with executing parallel.

So am I doing anything wrong in first program ? Is my first program running tasks in parallel, since I see without thread is taking less time?

Try to use Runnable instead of Callable. – Kachna Aug 01 '15 at 10:02 — Kachna, Aug 01 '15 at 10:02

score 1 · Answer 1 · edited May 23 '17 at 12:29

1

First one is sequential, second one is parallel -- that's fine.

It looks like the running time consists mainly of slow console write operations inside System.out.printlncall (see Why is System.out.println so slow?).

You should observe different behavior (and parallel version speedup) if you write to a file instead.

edited May 23 '17 at 12:29

Community

1
1

answered Aug 01 '15 at 09:55

mzc

3,265
1
20
25

score 1 · Accepted Answer · answered Aug 02 '15 at 18:21

What your tasks mostly do is writing into standard output using the System.out.println call which is PrintStream.println method. It eventually calls PrintStream.write method which body is synchronized. Thus you just waste time on creating threads and synchronization overheads. As PrintStream is sequential by nature, it cannot output in parallel, so when single stream is writing, others just waiting for it. Some operations can be parallelized like your for loop and concatenation of string and number, but they are much faster than the output to stdout.

To gain the additional performance from the concurrency you should avoid using the shared sequential resource. In your case it's standard output stream.

score 0 · Answer 3 · answered Aug 01 '15 at 15:04

Your code is correct. The result is due to the computation is too simple and run too fast. Most of the run time is decided by the speed of console output so the benefit of multi-threading can not make up for the overhead of setting up & shutting down the thread pool. Also, the try-catch setup also adds a small overhead (very small, but enough to tangle the result in this simple scenario). --> You could try to increase the loop size (hint: use a static variable MAX_LOOP for faster testing) and you will see the different.

Java: Using ExecutorService for concurrency

3 Answers3