DEV Community: Sonali Gupta

ExecutorService in Java

Sonali Gupta — Tue, 14 Jul 2020 18:50:29 +0000

ExecutorService ( Java's thread pool framework) -

In java, its always being easy to run a method or a piece of code asynchronously.

For Example -

In java, thread can be created in two ways,
1) By extending Thread class
2) By implementing Runnable Interface

If we want to execute a task asynchronously, than we can create a new instance of thread and assign the task to it. And start the thread, it will execute asynchronously.

Task can be executed asynchronously using threads. But, if suppose we want to execute 100000 tasks than we have to create 100000 threads. And each thread can execute one task at a time asynchronously. But, creating 100000 threads for each task is not the feasibile solution.

The Java ExecutorService is the interface which allows us to execute tasks on threads asynchronously. The Java ExecutorService interface is present in the java.util.concurrent package. The ExecutorService helps in maintaining a pool of threads and assigns them tasks. It also provides the facility to queue up tasks until there is a free thread available if the number of tasks is more than the threads available.

By using Executor service, we can create the pool of threads.

ExecutorService executorService = Executors.newFixedThreadPool(10);

Here, we are creating a pool of 10 threads. And 100000 tasks are submitted to the executor service. Internally, it assigns each task to the threads present in the thread pool. Max 10 threads can execute the task at a time. And the tasks are stored in the blocking queue.

Why Blocking Queue ? - Because No two threads can access the queue at the same time.

Once the threads execution completes, it fetches the next task from the blocking queue. And subsequently, all the threads present in the thread pool do the same.

Looping over array in JavaScript

Sonali Gupta — Wed, 12 Feb 2020 19:45:30 +0000

Looping over arrays-
There’s a few methods for looping over arrays in Javascript. We’ll start with the classical ones and move towards additions made to the standard.

While -
let index = 0;
const array = [1,2,3,4,5,6];

while (index < array.length) {
console.log(array[index]);
index++;
}

for (classical)-
const array = [1,2,3,4,5,6];
for (let index = 0; index < array.length; index++) {
console.log(array[index]);
}

forEach-
const array = [1,2,3,4,5,6];

array.forEach(function(current_value, index, array) {
console.log(At index ${index} in array ${array} the value is ${current_value});
});
// => undefined

map-
The last construct was useful, however, it doesn’t return a new array which might be undesirable for your specific case. map solves this by applying a function over every element and then returning the new array.

const array = [1,2,3,4,5,6];
const square = x => Math.pow(x, 2);
const squares = array.map(square);
console.log(Original array: ${array});
console.log(Squared array: ${squares});
The full signature for map is .map(current_value, index, array).

reduce-
The reduce() method applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.

const array = [1,2,3,4,5,6];
const sum = (x, y) => x + y;
const array_sum = array.reduce(sum, 0);
console.log(The sum of array: ${array} is ${array_sum});

filter-
Filters elements on an array based on a boolean function.

const array = [1,2,3,4,5,6];
const even = x => x % 2 === 0;
const even_array = array.filter(even);
console.log(Even numbers in array ${array}: ${even_array});

every-
Got an array and want to test if a given condition is met in every element?

const array = [1,2,3,4,5,6];
const under_seven = x => x < 7;

if (array.every(under_seven)) {
console.log('Every element in the array is less than 7');
} else {
console.log('At least one element in the array was bigger than 7');
}

some-
Test if at least one element matches our boolean function.

const array = [1,2,3,9,5,6,4];
const over_seven = x => x > 7;

if (array.some(over_seven)) {
console.log('At least one element bigger than 7 was found');
} else {
console.log('No element bigger than 7 was found');
}

Java Multithreading & Concurrency Overview

Sonali Gupta — Tue, 28 Jan 2020 18:36:02 +0000

Multithreading and Concurrency in Java-
Java was one of the first languages to make multithreading easily available to developers. Java had multithreading capabilities from the very beginning. Therefore, Java developers often face the problems described above. That is the reason I am writing this trail on Java concurrency. As notes to myself, and any fellow Java developer whom may benefit from it.

The trail will primarily be concerned with multithreading in Java, but some of the problems occurring in multithreading are similar to problems occurring in multitasking and in distributed systems. References to multitasking and distributed systems may therefore occur in this trail too. Hence the word "concurrency" rather than "multithreading".

Concurrency Models-

The first Java concurrency model assumed that multiple threads executing within the same application would also share objects. This type of concurrency model is typically referred to as a "shared state concurrency model". A lot of the concurrency language constructs and utilities are designed to support this concurrency model.

However, a lot has happened in the world of concurrent architecture and design since the first Java concurrency books were written, and even since the Java 5 concurrency utilities were released

The shared state concurrency model causes a lot of concurrency problems which can be hard to solve elegantly. Therefore, an alternative concurrency model referred to as "shared nothing" or "separate state" has gained popularity. In the separate state concurrency model the threads do not share any objects or data. This avoids a lot of the concurrent access problems of the shared state concurrency model.

New, asynchronous "separate state" platforms and toolkits like Netty, Vert.x and Play / Akka and Qbit have emerged. New non-blocking concurrency algorithms have been published, and new non-blocking tools like the LMax Disrupter have been added to our toolkits. New functional programming parallelism has been introduced with the Fork and Join framework in Java 7, and the collection streams API in Java 8.

Java Memory Model

Sonali Gupta — Sat, 11 Jan 2020 19:50:34 +0000

Hi Everyone,

Understanding JVM Memory Model, Java Memory Management are very important if you want to understand the working of Java Garbage Collection. Today we will look into memory management in Java, different parts of JVM memory.

JVM memory is divided into separate parts. At broad level, JVM Heap memory is physically divided into two parts – Young Generation and Old Generation.

Memory Management in Java –

Young Generation-
The young generation is the place where all the new objects are created. When the young generation is filled, garbage collection is performed. This garbage collection is called Minor GC. Young Generation is divided into three parts – Eden Memory and two Survivor Memory spaces.

Important Points about Young Generation Spaces:

Most of the newly created objects are located in the Eden memory space.
When Eden space is filled with objects, Minor GC is performed and all the survivor objects are moved to one of the survivor spaces.
Minor GC also checks the survivor objects and move them to the other survivor space. So at a time, one of the survivor space is always empty.
Objects that are survived after many cycles of GC, are moved to the Old generation memory space. Usually, it’s done by setting a threshold for the age of the young generation objects before they become eligible to promote to Old generation.

Old Generation -
Old Generation memory contains the objects that are long-lived and survived after many rounds of Minor GC. Usually, garbage collection is performed in Old Generation memory when it’s full. Old Generation Garbage Collection is called Major GC and usually takes a longer time.

Stop the World Event -
All the Garbage Collections are “Stop the World” events because all application threads are stopped until the operation completes.

Since Young generation keeps short-lived objects, Minor GC is very fast and the application doesn’t get affected by this.

However, Major GC takes a long time because it checks all the live objects. Major GC should be minimized because it will make your application unresponsive for the garbage collection duration. So if you have a responsive application and there are a lot of Major Garbage Collection happening, you will notice timeout errors.

The duration taken by garbage collector depends on the strategy used for garbage collection. That’s why it’s necessary to monitor and tune the garbage collector to avoid timeouts in the highly responsive applications.

Permanent Generation -
Permanent Generation or “Perm Gen” contains the application metadata required by the JVM to describe the classes and methods used in the application. Note that Perm Gen is not part of Java Heap memory.

Perm Gen is populated by JVM at runtime based on the classes used by the application. Perm Gen also contains Java SE library classes and methods. Perm Gen objects are garbage collected in a full garbage collection.