Monday, April 21, 2014

Concurrency, Parallelism, Multicore

There were considerate amount of updates to Java language, JDK & JVM in the recent release of 1.8. It was said that finally Java is addressing multi-core hugely in Java 8. So I got excited about multicore, concurrency, parallelism etc. Here I'm not going to talk about evolution of multicore or Moore's Law blah blah blah. I'm going to talk about what I learnt about concurrency & parallelism, especially in Java (may be about Go in future).

As Rob Pike said Concurrency is not Parallelism. Concurrency is about dealing with lot of things at ones whereas Parallelism is about doing lot of things at ones. Concurrency is to structure things so that we may use parallelism to do a better job. Parallelism is not the goal of Concurrency. Concurrency's goal is good structure. Parallelism can come from better concurrent expression of the problem. The parallelism performance by an application achieved varies with different hardware configurations, depending on number of cores, number of threads per core etc. But if we have a proper concurrent design we can get Parallelism whenever possible.

There are different types of approaches to concurrency, to name a few:

1) Memory Sharing - Java
2) Message Passing - Erlang, Go

There are different debates about different types of approaches. As of now there is no barometer to validate which one is better. We may measure & compare performances of different approaches though. Depending on the approach different languages uses different terminology, the rest of my discussion is more related to Java world. Though the final goal of any approach, given any programming language, is to take advantage of all the cores available on the processor to increase the performance of applications.

The number of cores on the processors are increasing year after year. Rather than waiting for the CPU clock speeds to increase, software applications should be fine tuned in order to use all the cores on the processor. Concurrency should be addressed at the design stage of the application. Each core usually has one thread (more than one in some cases like HyperThreading). The ultimate goal is to keep all the threads (in different cores) running at any given time. 

There are lot of issues that need to be dealt while creating multi-threaded applications like thread creation, thread life cycle management, scheduling etc. Luckily many programming languages provide us with necessary language features, frameworks in dealing with them. Multi-threaded applications should be designed very carefully because when different threads try to communicate it could lead to issues like dead locks, starvation etc. Each approach addresses them in respective ways. From the next post I will dive deep into concurrency in Java. How Java & JDK is evolved overtime to address concurrency, starting from Java 1.0 till Java 8.

No comments:

Post a Comment

Fork me on GitHub