Saturday, 1 April 2017

Best Practices for Multithreading in Java

A thread is a path of execution within a process. Multithreading is the ability to improve the overall throughput of an application by providing a way to execute many threads simultaneously. This article presents a discussion on the best practices that should be adopted when working with multi-threading in enterprise applications.

What is multithreading and why is it useful?


Multithreading may be defined as the ability to have multiple threads in memory with one of them in the execution state. Threads share the resources of a process that includes memory resources, process data and open files. This, though it helps to make your application more efficient, might cause issues at runtime due to concurrent access to the same resource.
Hence, you should be aware of the best practices that should be followed when working with multithreading in Java.

Using the Java Executor Framework


The Java Executor Framework was introduced in Java 1.5 and is contained inside the Java concurrency package. It provides an abstraction over the Java threading framework provided by the core Java runtime. It should be noted that creation of threads and executing them in a multithreaded environment is an expensive process, primarily due to the overhead involved in context switches between threads.

Java multithreading and concurrency best practices


Albeit the fact that the Java Programming Language provides excellent support for working with threads, it is imperative that you are extra careful when working with multithreading in enterprise applications to deal with concurrency and performance issues to design and implement applications that are high performant, secure and scalable. In this section, we will explore the best practices that are involved when working with multithreading in Java.

Immutable types


It is advisable to use immutable classes when working in Java. Examples of immutable classes are String, Integer, etc. In using immutable classes and types, you need not worry about concurrency issues. The reason is that instance of immutable classes once created cannot be changed. When you modify a String object, a new String object is created.

Use locking judiciously


You should write minimal code inside lock - just lock the critical sections only. That way the application performance would be much better. It is preferable to take advantage of the lock over synchronized keyword.

Local variables


It is a good practice to use local variables rather than using class or instance variables. You might wonder that creating a local variable every time for each method you write is a pain and you might think of reusing class level variables. However, reusability here would come at the cost of performance and concurrency problems. In using local variables more in your code, each thread that accesses the method would have their own copy of objects – this would reduce the concurrency issues that you would otherwise have to handle had those variables been shared or in a class scope.

Avoid using static objects


The static keyword in Java is used to create static method, class and objects. A static member in a class belongs to the class itself rather than the instances of the class. However, static objects create concurrency issues. Hence, it is advisable to avoid using static objects or static variables in your code unless they are absolutely needed. If you are using static variables, you can make them static final constants instead. Consider using read-only collections for thread safety.

Concurrent collections


You should take advantage of concurrent collections over synchronized collections. Concurrent collections are built using the locking mechanism of the lock interface and so they can leverage the native concurrency mechanisms of the Java Virtual Machine much better.