Java Concurrent API Packages — Part 1

Concurrent utils are included in the package java.util.concurrent package.
This package has two important sub packages namely — java.util.concurrent.atomic and java.util.concurrent.locks. We will discuss about them in upcoming blogs.

                                  

As of now, we will discuss about java.util.concurrent package. This defines the core features, that helps us to provide alternative approach to the existing synchronization and Interthread process communication.

There are certain key features available in this package, which includes
  • Synchronizers
  • Executors
  • Concurrent Collections
  • The Fork / Join Framework.
We will discuss about each of them elaborately in my upcoming blogs. A basic idea about each feature is discussed here.

Synchronizers

This helps us to provide a high level of Synchronizing the Communication or Interactions between Multiple threads. 
This feature further provides different type of Synchronization techniques like
  • Semaphore
  • CountDownLatch
  • CyclicBarrier
  • Exchanger
  • Phaser
These techniques are helpful in one or another way to solve the synchronization problem that occurs during thread execution. It also helps us to optimize the program execution.

Executors

As the name suggest, Executors helps to manage the thread execution. Here the Executor Interface is at the top of the Hierarchy and is used to start the thread. We also have Executor Service that extends the Executor Interface and includes some additional methods.

There are three class namely that implements this ExecutorService Interface and provides various functionalities namely
  • ThreadPoolExecutor
  • SchedulesThreadPoolExecutor
  • ForkJoinPool
This Executors class has several static utility methods, that helps us to handle various executors creations and use.

Also there are two other interfaces namely, Callable and Future Interface that are related to Executors class.

Future helps us to collect the value that is returned by the thread after its execution. It means the value get’s defined in the future.

Callable is used to define the thread that returns the value.

Concurrent Collections

As we all know that in java.util.concurrent, there are several concurrent classes that helps us to handle the concurrent execution.

One such concurrent class is Concurrent HashMap, this helps us to handle concurrent Hashmap execution, without actually locking the entire Hashmap for read and write access.

Apart from this there are ConcurrentLinkedQueue and CopyOnWriteArrayList.

Fork/JoinPool Framework

This Concurrent feature framework helps us to support parallel programming.

Here we have the following main classes namely, ForkJoinPool, ForkJoinTask, RecursiveAction and RecursiveTask.

java.util.concurrent.atomic

When we use any normal variables during the concurrent execution, the state of the variable cannot be maintained properly. 

This atomic package, helps us to use variable in the concurrent environment by effectively updating the value of the variable without any latency or using any locks.

To achieve this, atomic package has various classes namely AtomicInteger, AtomicLong, AtomicBoolean and AtomicReference etc with the methods like incrementAndGet(), decrementAndGet(), get(), compareAndSet() etc.,

The execute all at a time without any interruption as a single operation.

java.util.concurrent.locks

This package acts like an alternative approach to the existing traditional Synchronization methods. 

Here we have a Lock interface which works as it name suggest by locking the state of the object and releasing it after the task completion.

We have various methods in this interface namely unlock(), lock(), and tryLock() etc.
This provides a way better than the Existing Synchronization method.

I hope this gives you a basic understating about the various classes and interfaces in the Concurrent API package.

We will discuss about each and every concept in the upcoming blogs. Kindly give your feedback in the comments so that i can enhance my writing.

Comments

Post a Comment

Popular posts from this blog

Why Pointers are Eliminated in Java?

Image
 This is rare question but it is good to get prepared with such type of Questions as it may be asked in Beginner level. The first motivation is to make Java programming less complicated. Java is an easy-to-learn, object-oriented programming language. As is well known, the pointer idea is very confusing, challenging to understand (especially for beginners), and leads to coding errors.  The pointers concept was eliminated by the designers of Java in order to make it less complicated and more straightforward. Memory can be allocated and deallocated via pointers. Although this is a useful aspect of pointers, manually managing memory can occasionally be challenging for programmers. Pointers are not required because Java has an automatic garbage collection mechanism, which simplifies memory management. One of the major problems in the field of programming is security. Direct access to a memory address is provided through a pointer. As a result, it is simple to access any memory region and pe
Read more

What is the advancement made in Hashmap in Java 8?

Image
We'll talk about an intriguing update on HashMap performance Improvement Changes in Java 8. Due to a performance issue, the Oracle changed HashMap.  What is HashMap and How it is Implemented? It keeps the key-value pair in storage where it may be retrieved with the use of a key. You must be familiar with how HashMap is Implemented only then we can understand what was the performance issue we had earlier and how that has been overcome by Oracle in Java 8. As its name suggests, HashMap operates on the concept of hashing. Equals() and hashcode() are two of the methods included in the Java Object class. We need to appropriately override these methods in order to get our HashMap to behave as expected. Any problems with these approaches could even invalidate the entire purpose since there is a chance that the results won't be retrieved even if the key-value pair is still there. HashMap use the Basic Implementation of Map Interface. When there is a hash collision, the entry's Link
Read more

Integer.parseInt(“text”)

Image
  What will happen if we execute the program int a = Integer.parseInt(“text”) ? class HelloWorld { public static void main(String[] args) { int a = Integer.parseInt(“text”); System.out.print(a); } } When this program is executed this will throw the following Exception Exception in thread "main" java.lang.NumberFormatException: For input string: "text"at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)at java.base/java.lang.Integer.parseInt(Integer.java:652)at java.base/java.lang.Integer.parseInt(Integer.java:770) at HelloWorld.main(HelloWorld.java:7) This is because parseInt() is used to get the primitive data type of the given string. It need to accepts the Integer in the form of String. But here we have given "text" as an Input in place of Integer. So it has thrown Number for Exception. It can be corrected by giving any Integer as an Input. class HelloWorld { public static void main(String
Read more