Let's start with a new post in the Java concurrency series. This time we'll learn how to start cleanly new threads and to manage thread pools. In Java, if you have a Runnable like this : ```java Runnable runnable = new Runnable(){ public void run(){ System.out.println("Run"); } } ``` You can easily run it in a new thread : ```java new Thread(runnable).start(); ``` This is very simple and clean, but what if you've several long running tasks that you want to load in parralel and then wait for the completion of all the tasks, it's a little bit harder to code and if you want to get the return value of all the tasks it becomes really difficult to keep a good code. But like for almost any problems, Java has a solution for you, the Executors. This simple class allows you to create thread pools and thread factories. A thread pool is represented by an instance of the class ExecutorService. With an ExecutorService, you can submit task that will be completed in the future. Here are the type of thread pools you can create with the Executors class : Once you have a thread pool, you can submit task to it using the different submit methods. You can submit a Runnable or a Callableto the thread pool. The method return a Future representing the future state of the task. If you submitted a Runnable, the Future object return null once the task finished. By example, if you have this Callable : ```java private final class StringTask implements Callable { public String call(){ //Long operations return "Run"; } } ``` If you want to execute that task 10 times using 4 threads, you can use that code : ```java ExecutorService pool = Executors.newFixedThreadPool(4); for(int i = 0; i < 10; i++){ pool.submit(new StringTask()); } ``` But you must shutdown the thread pool in order to terminate all the threads of the pool : ```java pool.shutdown(); ``` If you don't do that, the JVM risk to not shutdown because there is still threads not terminated. You can also force the shutdown of the pool using shutdownNow, with that the currently running tasks will be interrupted and the tasks not started will not be started at all. But with that example, you cannot get the result of the task. So let's get the Future objects of the tasks : ```java ExecutorService pool = Executors.newFixedThreadPool(4); List> futures = new ArrayList>(10); for(int i = 0; i < 10; i++){ futures.add(pool.submit(new StringTask())); } for(Future future : futures){ String result = future.get(); //Compute the result } pool.shutdown(); ``` But this code is a bit complicated. And there is a disadvantage. If the first task takes a long time to compute and all the other tasks ends before the first, the current thread cannot compute the result before the first task ends. Once again, Java has the solution for you, CompletionService. A CompletionService is a service that make easier to wait for result of submitted task to an executor. The implementation is ExecutorCompletionService who's based on an ExecutorService to work. So let's try : ```java ExecutorService threadPool = Executors.newFixedThreadPool(4); CompletionService pool = new ExecutorCompletionService(threadPool); for(int i = 0; i < 10; i++){ pool.submit(new StringTask()); } for(int i = 0; i < 10; i++){ String result = pool.take().get(); //Compute the result } threadPool.shutdown(); ``` With that, you have the result in the order they are completed and you don't have to keep a collection of Future. Here we are, you have the tools in hand to launch tasks in parralel using performing thread pools. Using Executors, ExecutorService and CompletionService you can create complex algorithm using several taks. With that tools, it's really easy to change the number of threads performing in parralel or adding more tasks without changing a lot of code. I hope that this post will help you to write better concurrent code.