ExecutorSerive vs CompletionService

[amitabh mehra]

I am not able to understand the difference between the two. In case if I use an ArrayList of Future to store the Future returned to me by submitting the tasks through ExecutorService, is it not same as CompletionService implementation?

Also, I need help to identify why the following code does not exit after rendering the page.
Code description: To render a page, there are 2 main tasks: render text and render image (in code, 5 in numbers). For test purpose, I was creating Image data as simple print statement. Each image consists of random number (max of 5) of such statements.

import java.util.concurrent.*;
import java.util.*;
import java.util.Random;

class ImageData {
	private StringBuffer st;
	
	public ImageData(String image) {
		st = new StringBuffer(image);
		createImageData();
	}
	
	private void createImageData() {
		Random r = new Random();
		int i = r.nextInt(8);
		for (int k = 0; k < i; k++) {
			st.append("\nImage Data " ).append(k);
		}
	}
	
	public void printImage() {
		System.out.println(st);
	}
}

class ImageInfo {
	private ImageData id;
	private String image;
	
	public ImageInfo(int i ) {
		image = "Image " + i;	
		id = new ImageData(image);
	}
	
	public ImageData downloadInfo()  {
		return id;
	}
}

class Renderer {
	public final ExecutorService execService;
	public final List<Future<ImageData>> list = new ArrayList<Future<ImageData>>();
	public Renderer(ExecutorService exec) {
		execService = exec;
	}
	
	void renderPage() {
		System.out.println ("*********** Render Page **************");
		final List<ImageInfo> info = scanForImage();
		for(final ImageInfo im : info) {
			Callable<ImageData> task = new Callable<ImageData>() {
				public ImageData call() {
					return im.downloadInfo();
				}
			};
			list.add(execService.submit(task));
		}
		renderText();
		
		try {
			for(Future<ImageData> f : list) {
				ImageData id = f.get();
				renderImage(id);
			}
		} catch(InterruptedException ie) {
			ie.printStackTrace();
		} catch(ExecutionException ie) {
			ie.printStackTrace();
		}
		
		System.out.println("Page Rendered");
	}
	
	List<ImageInfo> scanForImage() {
		List<ImageInfo> l = new ArrayList<ImageInfo>();
		for(int i = 0 ; i < 5; i++) {
			ImageInfo im = new ImageInfo(i);
			l.add(im);
		}
		return l;
	}
	
	void renderText() {
		System.out.println("************ Render Text *****************");
		Random r = new Random();
		try {
			Thread.currentThread().sleep(r.nextInt(5) * 1000);
		} catch(InterruptedException ie) {
			ie.printStackTrace();
		}
		System.out.println("Text Rendered");
	}
	
	void renderImage(ImageData id) {
	System.out.println("************ Render Image*****************");
		Random r = new Random();
		try {
			Thread.currentThread().sleep(r.nextInt(5) * 1000);
		} catch(InterruptedException ie) {
			ie.printStackTrace();
		}
		id.printImage();
	}
}

public class Test {
	public static void main(String[] args) {
		ExecutorService e = Executors.newFixedThreadPool(3);
		Renderer r = new Renderer(e) ;
		r.renderPage();
		System.out.println("Done");
	}
}  

[Steve Luke]

amitabh mehra wrote:I am not able to understand the difference between the two. In case if I use an ArrayList of Future to store the Future returned to me by submitting the tasks through ExecutorService, is it not same as CompletionService implementation?

The CompletionService is basically a Queue which returns the Futures in the order which they complete. If you used an ArrayList for the same purpose you would have to look through each future and check if they are completed, then consume them. Of you would need to take each one in order, wait for it to complete, then do your work. The difference is that if you have 5 tasks, and they complete in the following order:
2, 1, 5, 4, 3

With the CompletionService you take() and wait for #2 to complete. Then do work on #2. Then you take() and get #1 - perhaps already done. You do the work on #1, then take() and get #5, etc... With the ArrayList you call #1's get() method which causes you to wait. While your consumer is sitting there doing nothing, #2 completes and sits there doing nothing. Then when #1 is done, you do your work, then get() #2, which is already done so do your work on it. Then you get() #3, which you have to wait for, and in the meantime #5 and #4 complete and sit doing nothing, wasting time.

So CompletionService is more efficient consumer Queue of the Futures since it returns the Futures as soon, and in the order in which they complete.

Also, I need help to identify why the following code does not exit after rendering the page.

The ExecutorService creates 3 new, non-Daemon threads. These Threads do not get killed when the tasks complete, they are pooled to be re-used if necessary. Because there are live, non-Daemon threads hanging around the application can't close. What you have to do is shutdown the ExecutorService . You have to be careful when you call it, though - because you don't want to shut down the service before all your tasks are submitted.

[amitabh mehra]

Thanks... that cleared my doubts!