DEV Community: Ehis Edemakhiota

Java Study Group: Motivation, Roadmap and Goals

Ehis Edemakhiota — Wed, 18 Mar 2026 12:22:08 +0000

Hi there!

My name is Ehis Edemakhiota and I’m excited to see that you’ve come here. I am a Software Engineer and Java is my first language- I have been writing Java for about 5 years. I enjoy writing and thinking in Java because it is structured, dependable and if understood well, can be used to build software that is scalable and reliable. I want to be like Java :).

A famous quote says: "if you want to go quickly then go alone, but if you want to go far then go with people" . I want to go far and I want to do so with you :). This is my motivation for starting this study group.

The goal of the study group is for beginner to expert level Java programmers to in 8-12 weeks be able to:

build production-ready Spring Boot applications,
be prepared for Java/ Spring Boot technical interviews,
contribute to real-world backend projects.

The topics of interest are:

Introduction to Java and Java control structures
Introduction to OOP and SOLID principles
Design Patterns
Java Arrays and Data structures
Functional programming in Java
Java concurrency
JVM Internals
Introduction to Spring Boot
Spring Boot persistence best practices
Spring Security
Logging and Observability in Spring Boot
Project Loom- Java 21 Virtual Threads
Problem solving with LeetCode

Some of the study materials include:

Spring Boot in Action
Spring Boot Up and Running
Spring Persistence Best Practices.
Relevant Medium and Baeldung.com articles
Articles from the Offical Spring documentation

Java & Spring Boot — 12-Week Study Group Roadmap

Format: 4 phases · 12 weekly sessions · Mixed levels (Beginner → Expert)

Goals: Build production-ready Spring Boot applications · Ace Java/Spring Boot interviews · Contribute to real-world backend projects

Overview

Phase	Title	Weeks	Focus
1	Java Foundations	1–3	Core Java syntax, OOP, Design Patterns + LeetCode
2	Advanced Java	4–6	Data Structures, Functional Programming, Concurrency
3	JVM & Spring Boot	7–9	JVM Internals, Spring Boot Core, Persistence
4	Production-Ready	10–12	Security, Observability, Project Loom, Capstone

Study Materials

Spring Boot in Action — Craig Walls
Spring Boot Up and Running — Mark Heckler
Spring Persistence Best Practices
Relevant articles from Baeldung.com
Relevant articles from Medium.com
Official Spring Documentation

Phase 1 — Java Foundations (Weeks 1–3)

On-ramp for beginners while giving intermediates a chance to solidify fundamentals. LeetCode problems are embedded in each session to immediately apply concepts.

Week 1 — Introduction to Java

Level: Beginner

Subtitle: Setup, syntax, control flow & LeetCode warm-up

Learning Goal

Write basic Java programs, understand primitive types, operators, and control-flow structures. Begin applying these immediately through easy LeetCode problems.

Key Concepts

JDK / JRE setup
Primitive types
Operators
if / else / switch
for / while / do-while
Methods & scope
String basics

Study Materials

Baeldung: Java Basics series
Official Java SE documentation
Medium: Java 101 for beginners
LeetCode: Explore — Java card

LeetCode Practice

Focus: Basic loops, conditionals & arithmetic. Solve in Java; submit and read other Java solutions.

Problem	Difficulty
1. Two Sum	Easy
9. Palindrome Number	Easy
13. Roman to Integer	Easy
412. Fizz Buzz	Easy
1342. Number of Steps to Zero	Easy

Week 2 — OOP & SOLID Principles

Level: Beginner

Subtitle: Classes, inheritance, interfaces & modelling kata

Learning Goal

Design Java classes using core OOP concepts, apply SOLID principles, and model solutions to LeetCode problems as well-structured classes.

Key Concepts

Classes & Objects
Constructors
Inheritance & super
Polymorphism
Interfaces & abstraction
Encapsulation
SOLID principles (S, O, L, I, D)

Study Materials

Baeldung: Java OOP guide
Medium: SOLID principles in Java
Official Java Docs: OOP trail
LeetCode: OOP-friendly problems list

LeetCode Practice

Focus: Model your solution as a class first, then implement. Practice naming and responsibility separation.

Problem	Difficulty
155. Min Stack	Medium
146. LRU Cache	Medium
706. Design HashMap	Easy
232. Implement Queue using Stacks	Easy
303. Range Sum Query — Immutable	Easy

Week 3 — Design Patterns

Level: Intermediate

Subtitle: GoF creational, structural, behavioural & pattern-recognition kata

Learning Goal

Recognise and apply common GoF design patterns; spot patterns inside LeetCode problem structures and justify your pattern choice.

Key Concepts

Singleton
Factory / Abstract Factory
Builder
Observer
Strategy
Decorator
Facade

Study Materials

Baeldung: Design Patterns in Java
Refactoring.guru pattern catalogue
Medium: GoF patterns explained
LeetCode: Patterns in coding problems (Medium article)

LeetCode Practice

Focus: Identify which GoF pattern maps to the problem structure before coding. Discuss your choice with the group.

Problem	Difficulty
284. Peeking Iterator	Medium
341. Flatten Nested List Iterator	Medium
460. LFU Cache	Medium
716. Max Stack	Medium
1603. Design Parking System	Easy

Phase 2 — Advanced Java (Weeks 4–6)

Raises the ceiling with Collections, the Streams/Lambda API, and Concurrency — high-frequency interview topics and prerequisites for understanding Spring Boot internals.

Week 4 — Arrays & Data Structures

Level: Intermediate

Subtitle: Collections framework & Big-O

Learning Goal

Select the right Java data structure for a problem and understand time & space complexity trade-offs.

Key Concepts

Arrays & multi-dimensional arrays
ArrayList / LinkedList
HashMap / TreeMap
HashSet / TreeSet
Queue / Deque / Stack
Big-O analysis

Study Materials

Baeldung: Java Collections guide
Official Java Docs: Collections framework
Medium: Data structures in Java

Week 5 — Functional Programming in Java

Level: Intermediate

Subtitle: Streams, lambdas & Optional

Learning Goal

Write idiomatic functional-style Java using the Streams API, lambdas, and method references.

Key Concepts

Lambda expressions
Functional interfaces
Stream API (map / filter / reduce)
Collectors
Optional<T>
Method references
Parallel streams

Study Materials

Baeldung: Java 8 Streams series
Official Java Docs: Stream API
Baeldung: Guide to Optional

Week 6 — Java Concurrency

Level: Advanced

Subtitle: Threads, locks & CompletableFuture

Learning Goal

Write thread-safe concurrent Java programs and use modern concurrency utilities effectively.

Key Concepts

Thread lifecycle
synchronized & volatile
ExecutorService / thread pools
Callable & Future
CompletableFuture
ReentrantLock
java.util.concurrent package

Study Materials

Baeldung: Java Concurrency series
Official Java Docs: Concurrency utilities
Medium: CompletableFuture deep dive

Phase 3 — JVM & Spring Boot (Weeks 7–9)

Opens with JVM internals so developers understand why their Spring apps behave the way they do, then moves into Spring Boot core and persistence.

Week 7 — JVM Internals

Level: Advanced

Subtitle: Memory model, GC & class loading

Learning Goal

Understand JVM architecture in depth to profile, tune, and diagnose Java applications in production.

Key Concepts

ClassLoader subsystem
Heap / Stack / Metaspace
GC algorithms (G1, ZGC, Shenandoah)
JIT compilation
JVM tuning flags
JFR / VisualVM profiling

Study Materials

Baeldung: JVM Internals series
Medium: Deep dive into the JVM
Official JVM specification

Week 8 — Introduction to Spring Boot

Level: Beginner

Subtitle: Auto-config, DI & REST APIs

Learning Goal

Bootstrap a Spring Boot project and build a functional REST API, understanding auto-configuration and dependency injection.

Key Concepts

Spring IoC container
Dependency injection
Auto-configuration
Spring Boot starters
@RestController / @Service
application.yml & profiles

Study Materials

Spring Boot in Action — Craig Walls
Spring Boot Up and Running — Mark Heckler
Official spring.io documentation

Week 9 — Spring Persistence

Level: Intermediate

Subtitle: Spring Data JPA, transactions & optimisation

Learning Goal

Implement a robust, optimised persistence layer with Spring Data JPA and handle transactions correctly.

Key Concepts

Spring Data JPA repositories
Entity mapping & relationships
JPQL & native queries
N+1 problem & fetch strategies
Transaction management
Flyway / Liquibase migrations

Study Materials

Spring Persistence Best Practices (book)
Baeldung: Spring Data JPA series
Official Spring Data JPA docs

Phase 4 — Production-Ready (Weeks 10–12)

Covers the operational concerns real teams care about: security, observability, and modern concurrency with Project Loom.

Week 10 — Spring Security

Level: Intermediate

Subtitle: Authentication, JWT & OAuth2

Learning Goal

Secure a Spring Boot application using JWT, OAuth2, and method-level authorisation.

Key Concepts

Security filter chain
UserDetailsService
JWT authentication
OAuth2 / OpenID Connect
Role-based access control
@PreAuthorize / @Secured

Study Materials

Spring Boot Up and Running — Ch. Security
Baeldung: Spring Security series
Official Spring Security reference docs

Week 11 — Logging & Observability

Level: Intermediate

Subtitle: Structured logs, metrics & tracing

Learning Goal

Instrument a Spring Boot app for full production observability: structured logs, metrics, and distributed traces.

Key Concepts

SLF4J / Logback configuration
Structured / JSON logging
Spring Boot Actuator
Micrometer metrics
OpenTelemetry tracing
Grafana / Prometheus integration

Study Materials

Baeldung: Spring Boot logging guide
Official Spring Actuator docs
Medium: Observability in Spring Boot
OpenTelemetry Java docs

Week 12 — Project Loom & Capstone

Level: Advanced

Subtitle: Virtual threads + final project

Learning Goal

Understand Project Loom, migrate to virtual threads, and deliver a capstone production-ready Spring Boot project.

Key Concepts

Virtual threads (JEP 444)
Structured concurrency (JEP 453)
Thread-per-request model
Performance benchmarking
Loom + Spring Boot integration
Capstone project presentation

Study Materials

JEP 444: Virtual Threads specification
Baeldung: Project Loom guide
Official Spring Docs: Virtual threads
Medium: Spring Boot + Project Loom

Format of each session

90–120 minutes per session — 20 min concept review, live coding exercise, then group discussion.
Beginners with intermediates during coding exercises. Experts take ownership of advanced weeks (6, 7, 12) as lead facilitators.
Where applicable, the last 20–30 minutes of each Phase 1 session for a live group LeetCode walk-through where one member screen-shares and others review the solution.
Where applicable, before live coding include a Design Patterns Kata: "Which GoF pattern does this problem smell like, and why?"
Capstone Project: Members of the study group will be paired. Each pair will work together to ship a small but complete production-grade Spring Boot application demonstrating persistence, security, and observability.

If this feels like you and you can commit for the duration of the study group, then I invite you to join me on this journey. Let's go far and grow deep together.

Cheers!

Solving The Add Two Numbers Leetcode Question

Ehis Edemakhiota — Sat, 24 Jan 2026 23:09:50 +0000

Question

You are given the starting nodes of two LinkedLists. Each LinkedList represents a reversed integer value: that is the value 768 is represent in linked list form as 8->6->7. The task is to add the numbers in the linked list and then return the head of a new linked list representing the sum with the numbers reversed.

Clarifying Questions

Are the values of the ListNodes between 0 and 9? This question is important because we want to keep track of carry values after addition.
What are the maximum values represented by a LinkedList? This question is important because we want to it would determined the approach to take. If the maximum values represented by a linkedlist can be the INTEGER.MAX_VALUE then this means that we cannot "integerify" both linked lists and then convert the result to a list and then return the head.
Do both input lists have the same number of nodes? This question would determine the constraints in your solution.

Approach 1: Brute Force

The brute force approach to solving this is "integerify" both input lists, add the resulting integers and then finally convert the sum to a list.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int l1Str = convertToInt(l1);
        int l2Str = convertToInt(l2);
        int sum = l1Str + l2Str;
        ListNode result = convertToList(sum);
        return result;
    }

    private ListNode convertToList(int num){
        ListNode head = new ListNode(num%10);
        num = num/10;
        ListNode current = head;
        while (num>0){
            current.next = new ListNode(num%10);
            num = num/10;
            current = current.next;
        }
        return head;
    }

    private int convertToInt(ListNode l) {
        ListNode current = l;
        StringBuilder sb = new StringBuilder();
        while (current!= null) {
            sb.append(current.val);
            current = current.next;
        }
        return Integer.parseInt(sb.reverse().toString());
    }
}

The time complexity for this solution is O(max(N,M)) and space complexity is O(n). However this solution fails for the edge case 9999999991 and 9 because 9999999991 overflows the java integer data type.

Approach 2:

My second approach was to traverse both lists and add the corresponding digits individually. This meant that I needed to track the carry (most significant digit after every addition), while I create a new list node with the least significant digit as the val. I created two ListNode variables one to keep track of the result and the other to keep track of the current additions.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int carry = 0;
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        while (l1 != null || l2 != null || carry != 0) {
            int l1Val = l1 != null ? l1.val : 0;
            int l2Val = l2 != null ? l2.val : 0;
            int sum = l1Val + l2Val + carry;
            current.next = new ListNode(sum%10);
            carry = sum/10;
            current = current.next;
            if (l1 != null){
                l1 = l1.next; 
            }
            if (l2 != null) {
                l2 = l2.next;
            }
        }
        return dummy.next;
    }
}

Time Complexity: O(max(n,m))

Space Complexity: O(n)

Java Thread Life Cycles

Ehis Edemakhiota — Sat, 05 Mar 2022 12:11:36 +0000

Introduction

A thread is the smallest unit of processing. A thread can be in different states in a cycle leading from its creation to its termination.
This article explores the different states in the Java thread life cycle. This is the second article of a concurrency series. The first article introduced the concepts of Multi-threading, Concurrency, Asynchronous Programming and Parallel Programming. You might want to take a look here.

Definition of Terms

Process: A process is an instance of a program that is currently being executed by the processor. Different instances of the same program can run on a computer as different processes. This means that when I run MS Word on my computer, for instance, it runs as a process. I can run different instances of MS Word on my computer. For each new instance of MS Word, the processor spins up a new process. Each process has its own unique stack, memory and data.
Thread: A thread is a subset of a process. A process starts with one thread called the main thread. The main thread can branch into other threads. A process that contains only the main thread is called a single-threaded process. A process that contains more than one thread is called a multi-threaded process. All threads within a process all share the same code-segment, data-segment, registers, stack and program counter.

Lifecycle of threads in Java

Java supports multithreading. A Java program can be designed in such a way that its different parts run on different threads. The execution of a Java program begins from the main method. The main method is executed on a special thread called the main thread, which is created by the Java Virtual Machine(JVM). Other threads are created as off-shoots of the main thread.

In Java, threads belong to the class- java.lang.Thread. You can create a Java thread by implementing the Runnable interface as shown in the following block:

/*
 * CREATING A JAVA THREAD BY IMPLEMENTING THE RUNNABLE INTERFACE
*/

public class SimpleThreadTwo implements Runnable{

    //the run method contains code that the thread will execute
    @Override
    public void run() {
        System.out.println("A simple thread has been created by implementing the Runnable interface");
    }
}

You can also create a Java thread by extending the Thread class as shown in the following block:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
* CREATING A JAVA THREAD BY EXTENDING THE THREAD CLASS
* */


public class SimpleThread extends Thread {

    // the run method contains code that the thread will execute
    @Override
    public void run() {
        System.out.println("A simple thread has been created by extending the Thread class");
    }
}

To execute both threads defined above, you create an ExecutorService. The ExecutorService provides a thread pool that allows you to execute threads using the execute method as shown below:

//creating an executor service that executes threads
class Executor{
    public static void main(String[] args) {
        SimpleThread simpleThread = new SimpleThread();
        SimpleThreadTwo simpleThreadTwo = new SimpleThreadTwo();

        // create the thread pool
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(simpleThread);
        executorService.execute(simpleThreadTwo);

        //the shutdown method notifies the executor service to stop accepting new tasks
        //but the executor service still continues to run tasks that have already been accepted
        executorService.shutdown();
    }
}

Output:

A simple thread has be created by extending the Thread class
A simple thread has been created by implementing the Runnable interface

Process finished with exit code 0

You can also execute threads using the Thread class by invoking the start method. To execute a thread created by extending the Thread class, you have to invoke the start method on the thread object as follows:

Take note that you have to first create a class that extends java’s Thread class. (Using the SimpleThread class created above)

public class MyThread {
    public static void main(String[] args) {
        SimpleThread simpleThread = new SimpleThread();
        simpleThread.start();
    }
}

Output:

A simple thread has be created by extending the Thread class

Process finished with exit code 0

To execute a thread created by implementing the Runnable interface, you have to pass in a Runnable as an argument to the Thread constructor. This is demonstrated in the code block below:

Take note that you have to first create a class that implements java’s Runnable class before you can do this.
(Using the SimpleThreadTwo class created above.)

public class MyThread {
    public static void main(String[] args) {
        SimpleThreadTwo simpleThreadTwo = new SimpleThreadTwo();

        //passing the Runnable object as an argument into the Thread class
        Thread thread = new Thread(simpleThreadTwo);
        thread.start();
    }
}

Output:

A simple thread has been created by implementing the Runnable interface

Process finished with exit code 0

It is important to highlight that creating a thread by implementing the Runnable interface is more encouraged than creating threads using the Thread class.

The java.lang.Thread class has a static enum property- State. The State property defines the potential state of a Java thread. During its life cycle, a java thread can belong to any of the following states:

NEW
RUNNABLE
WAITING
TIMED-WAITING
BLOCKED
TERMINATED

The following is a diagrammatic representation of the java thread lifecycle:

Source: baeldung.com

The following section describes these thread states in more detail:

NEW: When a thread is created, it is in the NEW state. A thread remains in the new state until its start method is called.

public class MyThread {
public static void main(String[] args) {
            SimpleThreadTwo simpleThreadTwo = new SimpleThreadTwo();
            //passing the Runnable object as an argument into the Thread constructor
            Thread thread = new Thread(simpleThreadTwo);
            System.out.printf("The current state of thread is %s", thread.getState());
    }
}

Output:

The current state of thread is NEW

Process finished with exit code 0

RUNNABLE: A thread is in the RUNNABLE state when the processor executes its start method. Threads in the RUNNABLE state are either READY to run or are already RUNNING.

When a thread transitions to the RUNNABLE state, the thread starts first in the READY state. At the READY state, the thread has not been assigned processor time also called a quantum or a time slice. When a thread is assigned a time slice, the thread is said to be dispatched. A newly dispatched thread joins a queue of other dispatched threads that are also waiting to run. The operating system uses a Thread Scheduler to determine which thread to run.

When a thread starts to run, it transitions into its RUNNING state. In the RUNNING state, the task defined within the run method of the threads is executed.

public class MyThread {
    public static void main(String[] args) {
            SimpleThreadTwo simpleThreadTwo = new SimpleThreadTwo();
            //passing the Runnable object as an argument into the Thread constructor
            Thread thread = new Thread(simpleThreadTwo);
            // the start method executes the code defined in the run method of the thread
        thread.start();
            System.out.printf("%nThe current state of thread is %s%n", thread.getState());
    }
}

WAITING: A thread enters the WAITING state while it waits for another thread to perform a task. A running thread can be placed on wait when one of the following methods is invoked:
- wait: The wait method causes an object to give up its timeslice and to release the monitor lock on a synchronized object. A monitor lock is a contract that gives a thread sole access to an object. The wait method causes the object to give up processor time and to transition from the RUNNING state to the WAITING state. A thread in waiting can transition back into execution when the thread that currently has the monitor lock calls the notify or notifyAll method.
- LockSupport.park: The LockSupport.park method disables a thread unless a permit is available. A permit is a permission for a thread to continue execution. When the park method is called on the current thread, the thread remains in the WAITING state. When some other thread invokes the unpark method with the parked thread as the target, the parked thread goes back into the RUNNING state.
- join: The join method allows a thread to remain in the WAITING state until another thread completes execution.

public class WaitingStateDemo implements Runnable{
    public static Thread firstThread;

    public static void main(String[] args) {
            firstThread = new Thread(new WaitingStateDemo());
            firstThread.start();
    }
    @Override
    public void run() {
            Thread secondThread = new Thread(new WaitingStateDemoInner());
            secondThread.start();
         try {
                secondThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }


    static class WaitingStateDemoInner implements  Runnable{

            @Override
            public void run() {
                System.out.println("The current state of thread 2 is " + firstThread.getState());
        }
    }
}

Output:

The current state of thread 2 is WAITING

Process finished with exit code 0

Execution starts from the main method in the above program.

First, we create firstThread and invoke its run method by calling start.
In the run method of firstThread, we create secondThread and start it.
While the processing of firstThread continues, we call the join method on secondThread. The join method puts firstThread in the WAITING state until secondThread has finished its execution.
Since firstThread is waiting for secondThread to complete, you can get the state of firstThread from secondThread.

To better understand the WAITING state, consider this scenario:

You have an onsite interview for a position that has the prospects of an amazing salary. On your arrival for the interview, the secretary tells you to wait until the hiring manager notifies you to come in. At this point, you are in the WAITING state. You cannot proceed to the interview until the hiring manager notifies you to come in.

TIMED-WAITING: A thread enters the TIMED-WAITING state when it is waiting for another thread to perform a task within a specified time interval. A thread can be put in the TIMED-WAITING state by calling one of the following methods:
- thread.sleep(long millis)
- thread.wait(int timeout) or thread.wait(int timeout, int nanos)
- thread.join(long millis)
- LockSupport.parkNanos
- LockSupport.parkUntil

You can demonstrate the TIMED-WAITING state by creating a thread from the main thread. You can call the sleep method on the offshoot thread. This is shown as follows:

public class TimedWaitingStateDemo {
    public static void main(String[] args) {
            Thread newThread = new Thread(new DemoThread());
         newThread.start();

        // the following sleep gives the ThreadScheduler enough time to start processing newThread
         try {
                Thread.sleep(1000);
             System.out.println("The current state of newThread is: " + newThread.getState());
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
             System.err.println("Thread interrupted " + e);
         }
    }
}

class DemoThread implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("Thread interrupted " + e);
        }
    }
}

A thread in the TIMED-WAITING state transitions back to the RUNNABLE **state when the task it is waiting for completes execution or when the specified time interval elapses. To better understand the **TIMED-WAITING state, consider the following scenario:

You and a friend in another city get tickets to go see a music concert organized in your city. On the day of the concert, you agree with your friend to wait for him until 2 pm. If he does not arrive on/before 2 pm, you can go to the concert alone. Here, you are placed in the TIMED-WAITING state. You can choose to proceed with going to the concert after the specified time (until 2 pm) has elapsed.

BLOCKED: A thread transitions into the BLOCKED state when one of the following happens during program execution:
- When the thread is waiting for an I/O operation to complete.
- When the thread is waiting to gain access to the monitor lock on a synchronized object. A monitor lock is a contract that gives a thread sole access to a synchronized object. A synchronized object is an object that is designed to be accessed by only one thread at a time.

To understand the BLOCKED state, consider this scenario:

You have a meeting with a friend but as you step out of your house, it begins to rain. At this point, you are in a BLOCKED state. You are blocked from meeting with your friend until the rain stops.

TERMINATED: A thread enters the TERMINATED state ( sometimes called the DEAD state) when one of the following happens:
- when it completely executes its task ( as defined in the run method).
- when it terminates due to an error.

public class TerminatedStateDemo implements Runnable{
    @Override
    public void run() {
            System.out.println("This demo is to show the terminated state");
}

    public static void main(String[] args) throws InterruptedException {
         Thread newThread = new Thread(new TerminatedStateDemo());
         newThread.start();
        // this sleep is intended to enable newThread execute completely
         Thread.sleep(5000);
         System.out.println("The current state of the new thread is : " + newThread.getState());
    }
}

Output:

This demo is to show the terminated state
The current state of the new thread is: TERMINATED

Process finished with exit code 0

Thread Priorities and Thread Scheduling

The number of services assigned to a given thread is referred to as its priority. Every Java thread has a thread priority. The order in which threads are scheduled is determined by each thread’s thread-priority. Threads with a higher thread-priority are executed before threads with a lower thread priority. In Java, thread-priorities are scaled on a scale of 1 to 10.

1 is the lowest priority.
5 is the standard priority.
10 is the highest priority.

The priority of the main thread is set to 5 by default. Thread priority is a transferred property. Since every java thread is created off the main thread, every thread starts with a priority of 5. The priority of a thread can be programmed using the setPriority method. The following enums represent thread priorities:

Thread.MIN_PRIORITY represents the lowest priority.
Thread.NORM_PRIORITY represents the standard priority.
Thread.MAX_PRIORITY represents the highest priority.

Below is a program to understand the Thread-Priority:

public class ThreadPriority implements Runnable{
    @Override
    public void run() {
        System.out.println("The thread priority of the running thread is " + Thread.currentThread().getPriority());
    }

    public static void main(String[] args) {
        Thread firstThread = new Thread(new ThreadPriority());
        Thread secondThread = new Thread(new ThreadPriority());

        firstThread.setPriority(Thread.NORM_PRIORITY);
        secondThread.setPriority(Thread.MAX_PRIORITY);

        firstThread.start();
        secondThread.start();
    }
}

Output:

The thread priority of the running thread is 5
The thread priority of the running thread is 10

Process finished with exit code 0

It is important to note that thread priorities alone do not guarantee the order in which threads execute.

An Operating System’s Thread Scheduler determines the order with which threads run. A simple implementation of the Thread Scheduler ensures that threads with the same level of priority are assigned processor resources in a round-robin fashion. However, Thread Schedulers are not that simple. Concurrency is a complex concept and the JVM provides utilities that abstract these complexities from the programmer.

Starvation and DeadLock

Thread priorities determine the order in which threads are executed. Depending on the Operating System, a steady influx of higher priority threads could cause lower priority threads to stay in the waiting state indefinitely. Such indefinite postponement of thread execution is called starvation.
Closely, related to starvation is the concept of DeadLock. To explain Deadlock, let us say that there are two threads- Thread 1 and Thread 2. Thread 1 cannot execute because it is waiting (directly or indirectly) for Thread 2 to execute. Simultaneously, Thread 2 cannot execute because it is waiting for Thread 1 to execute. Both Thread 1 and Thread 2 are blocking each other, hence the term deadlock. The concept of deadlock concurrency is analogous to a traffic jam.

Conclusion

In this article, you learnt about the different states of Java threads, from time of creation to termination.
I hope that you enjoyed the article and learnt something new too. You can follow me on Twitter on @ehizman https://twitter.com/ehizman_tutorEd. This will help me write more valuable content.

Special shout-outs to Confidence Okere, Oladimeji Omotosho, and Ozi Okoroafor for helping me with reviews and edits.

I look forward to hearing from you. Always code with ❤️

Distinguishing between Concurrency, Parallelism, Asynchronous Programming and Multi-threading

Ehis Edemakhiota — Mon, 07 Feb 2022 22:50:29 +0000

Cover Photo by Martin Sanchez on Unsplash

Introduction

Hello Everyone!

So, I have always wondered how applications handle multiple client requests simultaneously. My curiosity led me to study the following concepts:

Concurrency
Asynchronous Programming
Parallelism
Multi-threading

During my study, I realized that many people often confuse these concepts. This article aims to simplify these concepts for newbies to programming.

Having said the lot, let’s jump right into it.

Concurrency

Concurrency refers to the coordination and management of multiple tasks happening at the same time. The concurrently running tasks can be parts of the same program, methods of the same program or even different programs. The need for more processing speed makes concurrency an important concept in computing.

Concurrency is visible in everyday computing, for instance:

You can use a word processor program and at the same time listen to music on the same computer.
You can run multiple instances of the same application on our computer at the same time.
Multimedia streaming applications allow you to download a file and consume it at the same time.

The increased demand for computers that support multiple processors has facilitated concurrent programming. Parallelism makes concurrency possible in a multi-processor system. Concurrency is possible in a single processor system via Context-Switching. Context switching is a system whereby the processor assigns resources to tasks based on two factors:

time slice
task priority

Parallelism

Parallelism in computing refers to a paradigm where programs are designed to run concurrently on more than one processor.
The process of parallelism is described as follows:

A problem is broken into discrete tasks that can be solved concurrently
Each task is further broken down into a series of instructions
Instructions from each task execute simultaneously on different processors
A system that coordinates message sharing and synchronization between processes is employed.

The increased usage of multi-core processors and GPUs have facilitated parallel processing. Parallelism is utilized heavily in Game Development. GPUs work together with CPUs to increase the throughput of data and the number of concurrent calculations within an application.

image source: https://hpc.llnl.gov/sites/default/files/parallelProblem.gif

Asynchronous Programming

In other to understand the concept of asynchronous programming, you should first understand the concept of synchronous programming.

In synchronous programming, the processor executes tasks in a sequence. The currently running task must first finish before the processor picks up the next task for execution. In synchronous programming, tasks execute in a blocking fashion(the execution of the next task is blocked until the current task is finished).

In asynchronous programming, the processor executes tasks simultaneously. The processor does not wait for a task to complete execution before it picks up another task. This fashion of simultaneous execution is referred to as non-blocking.

In a computer program, experts advise that a function should be asynchronous when it performs a lengthy operation. A function is designed for asynchrony by including a callback function when invoking them. The asynchronous function executes the callback when it has completed execution as a way of notifying the program about its completion. The execution of the asynchronous function does not block the execution of other functions.

Asynchronous programs can be single-threaded or multi-threaded. So in asynchronicity, you see dependencies between several parts of a single process

image source: https://www.linkedin.com/pulse/asynchronous-calls-spring-boot-using-async-annotation-omar-ismail/

Multi-threading

A thread is a unit of work or a task. An operation can be split to run on multiple threads. Multi-threading refers to the concurrent/ parallel execution of multiple threads.

In single-processor systems, Multi-threading is achieved via context-switching.

In multi-processor systems, Multi-threading is achieved via parallelism.

image source: https://www.baeldung.com/cs/async-vs-multi-threading

A basic example of multi-threading is downloading two files from two different tabs in a web browser. Each tab uses a new thread to download the requested file. No tab waits for the other one to finish, the downloads run concurrently.

Multi-threading is breaking down tasks into threads that can be executed by different processors. Asynchronous programs can be multi-threaded or can be single-threaded.

A program that runs in parallel is also multi-threaded since parallel programs are designed in such a way that they can be broken down into discrete threads that run over multiple processors in a multi-processor system

To solidify the concepts, I find the following analogies quite useful:

Parallelism is like hiring two chefs( 2 processors). One cooks rice (one process) using a set of resources(stove and pots) and the other prepares stew (another process) using another set of resources.

Single-threaded asynchronicity is like setting to cook fried rice. You place the rice on fire to cook and while the rice is cooking, you slice your vegetables and make a sauce. After the rice is cooked, you mix the rice and the sauce

Multi-threaded asynchronicity is like you setting out to cook fried rice with your brother. You place the rice on fire to cook while he slices the vegetables. You make a sauce while he sets the table for the meal. (All these three tasks involved in the process of cooking rice are interdependent. One process does not wait for the other to finish). When the rice is cooked, you proceed to mix it with the sauce.

I hope that you enjoyed the tutorial and learnt something new too. You can follow me on Twitter on @ehizman. This will help me write more valuable content.

Special shout-outs to @nomso_okere and Mr Debola Olowose for helping me with reviews and edits.

I look forward to hearing from you.

Always code with ❤️

How the JVM Works

Ehis Edemakhiota — Mon, 10 Jan 2022 15:01:18 +0000

Introduction

When we write programs (source code) in Java (or in any other compiled language), the execution process is as follows:

The source code written by the programmer is converted to machine code or byte code. The machine code or byte code is then executed by the processor of the host machine or by a virtual machine on the host machine that emulates a processor. Languages like C, C++, Go and Rust compiles source code into machine code that is executed by the processor of the host machine. Languages like Java, Kotlin, Groovy and Scala convert source code into an intermediate language known as byte code that is executed by a virtual machine called the JVM(Java Virtual Machine).

Portability is a benefit of the JVM. The same byte code can run on all machines that have the JVM installed without any need for modification.
The JVM facilitates Java's slogan- "write once, run anywhere". The JVM is installed as part of one of the following:

the Java Development Kit(JDK)
the Java Runtime Environment(JRE)

The JVM creates space on a host machine to execute Java programs and it operates irrespective of the operating system or platform of the host machine. An instance of the JVM is provided whenever a Java program needs to be executed or run.

This article gives an insight into how the JVM works. An understanding of how the JVM works is important for Java programmers at all levels. At the end of this article, the reader should be able to:

describe the JVM and explain how it facilitates "write once, read anywhere"
describe the components of the JVM
describe the function of each component of the JVM
explain the causes of common JVM errors

Components of the JVM

The JVM consists of the following five components:

Class Loader
Runtime Data Area
Execution Engine
Java Native Interface(JNI)
Native Method Libraries

The following image shows the components of the JVM:

Let us describe each component in detail.

Class Loader

The javac compiler converts source code written by the programmer into byte code, which is resident in a .class file. The class loader loads .class files into the main memory. In a Java application, the class that contains the main method is first loaded into memory.

The phases involved in loading a .class file into memory are as follows:

Loading Phase
Linking Phase
Initialization Phase

The following image depicts the phases of the JVM class loader:

Let us talk about these three phases in a lot more detail.

1. Loading Phase: A class loader reads the generated byte code in .class file. It parses the data in the byte code and then stores the following information in an area of the JVM memory called the Method Area:

The kind of object that the parsed byte code represents- if it represents a Class, an Interface or an Enum.
The fully qualified name of the Class, Interface or Enum that the byte code represents and fully qualified name of the immediate parent
Information about the fields and methods in the Class, Interface or Enum.

Finally, the JVM creates an object of type Class and a class loader loads the object of type Class into an area of the JVM memory called the Heap Area using the ClassLoader.loadClass method.

The object of type Class can be used by a programmer to retrieve class-related information. Let us do a small demonstration as follows:

import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassInformation {
    public static void main(String[] args) {
        _Native newNative = new _Native("Joe Doe", "SCV070001");
        Class aClass = newNative.getClass();
        String className = aClass.getSimpleName();
        System.out.printf("The class of aClass: %s%n", className);
        System.out.printf("The following methods are defined in %s:%n", className);
        Method[] methods = aClass.getDeclaredMethods();
        for (Method method: methods) {
            System.out.printf("%7s%n", method.getName());
        }
        System.out.printf("The following fields are defined in %s:%n", className);
        Field[] fields = aClass.getDeclaredFields();
        for (Field field:fields) {
            System.out.printf("%7s%n", field.getName());
        }
    }
}
class _Native{
    private String name;
    private String scv;
    public _Native(String name, String scv) {
        this.name = name;
        this.scv = scv;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getScv() {
        return scv;
    }
    public void setScv(String scv) {
        this.scv = scv;
    }
}

We obtain the following output:

The class of aClass: _Native
The following methods are defined in _Native:
getName
setName
 getScv
 setScv
The following fields are defined in _Native:
   name
    scv

Note that for every .class file only one object of type Class is produced.

Three types of class loaders exist. They are described as follows:

1. The Bootstrap ClassLoader: The Bootstrap Class Loader is the root class loader. It loads classes in the Java standard packages like java.lang, java.io, java.net and java.util into the Heap Area. These packages are found in the rt.jar file and other core libraries present in the $JAVA_HOME/jre/lib directory.

2. The Extension ClassLoader: The Extension Class Loader is a child of the Bootstrap Class Loader. The Extension Class Loader loads the extensions of standard Java libraries(which are present in the $JAVA_HOME/jre/lib/ext directory) into the Heap Area.

3. The Application Class Loader: The Application Class Loader is a child of the Extension Class Loader. It loads files that are present in the application's classpath into the Heap Area. By default, the application's classpath is set to the current directory of the application.

The JVM follows the Delegation-Hierarchy principle whenever it tries to find a class. The task of finding a referenced class begins with the Bootstrap Class Loader. If the Bootstrap Class Loader is unable to find a class it delegates the task to the Extension Class Loader and if the Extension Class Loader cannot find the referenced class, it delegates the task to the Application Class Loader. If the Application Class Loader cannot find the referenced class, then a NoClassFoundError or a ClassNotFoundException is triggered.

2. Linking: The Linking phase involves the following processes:

Verification
Preparation
Resolution

Let us describe these processes in more detail:

- Verification: A ByteCodeVerifier verifies if the semantics of the byte code in a .class file is valid. If the verification fails, a java.lang.VerifyError is triggered. For instance, if the code has been built using Java 11 but is being run on a system that has Java 8 installed, the verification process will fail.

- Preparation: The JVM allocates memory for the class variables and initializes the variables to their default values according to their types.

- Resolution: The JVM replaces symbolic references with their actual references which are present in the Method Area of the JVM memory. For instance, if you have references to other classes or to variables or constants defined in other classes they are replaced with their actual references in this phase.

3. Initialization: After the processes of loading and linking a class or an interface, the JVM executes the initialization method of a class or an interface(also known as <clinit>). During the process of executing the initialization method of a class or interface, the following takes place:

the class's constructor or static block is executed
the class's super-classes are initialized(if they are not already initialized)
the class's variables are assigned their values as specified by the programmer

The Runtime Data Area

The Runtime Data Area consists of five components, which are shown in the image below:

Let us look at each one individually:

1. Method Area: In the Method Area, class-related information like the class name, the parent name, method information, and variable information are stored

If the available memory in the Method Area is not sufficient when loading a program into memory, an OutOfMemoryError is triggered. The Method Area is created when the JVM starts up. There is only one Method Area per instance of the JVM in a machine. In a multi-threaded environment, all threads shared the same Method Area.

2. Heap Area: All objects and their corresponding instance variables, as well as arrays, are stored in the Heap Area. The Heap Area is also created when the JVM starts up. There is only one Heap Area per instance of the JVM in a machine. In a multi-threaded environment, all threads shared the same Heap Area.

Note that since the Heap Area and the Method Area are shared resources, the information stored in these areas are not thread-safe.

3. Stack Area: Whenever the JVM creates a new thread, a new Stack Area is created. A Stack Area is divided into blocks called Activation Records or Stack Frames. Whenever a method call occurs, the following are pushed to the next available Stack Frame in a Stack Area:

the local variables of the calling method
the return address that the called method needs to return to the calling method

After a method call occurs the corresponding Stack Frame for that method call is popped off the Stack Area.

When a thread requires a larger stack size than what is available in the Stack Area, a StackOverflowError is triggered.

Note that the Stack Area is not a shared resource, hence it is thread-safe

4. Program Counter(PC) Registers: PC registers hold the address of the instruction currently executed by the JVM. After an instruction is executed, the PC register is loaded with the address of the next instruction. In a multi-threaded environment, each thread has its PC register

4. Native Method Stacks: In a multi-threaded environment, each thread has its Native Method Stack. Information about native methods (methods written in C and C++) are stored in the Native Method Stack.

Execution Engine

After the Class Loader loads the byte code into memory, the Execution Engine uses the details in the Runtime Data Area to execute instructions. It executes instructions in a byte code using the following components:

Interpreter
Just-In-Time(JIT) compiler
Garbage Collector

- Interpreter: The Interpreter reads each line of byte code instruction and executes it. The line by line execution of instructions by the interpreter makes it slow. A drawback of the Interpreter is that multiple calls to the same method require interpretation at each time.

- Just-In-Time(JIT) compiler: The Execution Engine uses the JIT compiler for execution whenever it finds repeated code in a byte code. The JIT compiler scans the entire byte code and converts it to native machine code. The JIT compiler replaces repeated code with the direct native code so that re-interpretation is not required.

The JIT compiler has the following components:

1. Intermediate Code Generator: The Intermediate Code Generator generates intermediate code.

2. Code Optimizer: The Code Optimizer optimizes intermediate code generated by the Intermediate Code Generator for better performance.

3. Target Code Generator: The Target Code Generator converts the optimized intermediate code into native machine code.

4. Profiler: The Profiler finds hotspots- code that is executed repeatedly. Whenever repeated code is encountered during execution, the JIT compiler recognizes that the code has a hotspot and it replaces the repeated code with its corresponding direct native code.

- Garbage Collector: The Garbage Collector performs Garbage Collection on the Heap Area. Garbage Collection is the process of removing unreferenced objects from the Heap Area. Garbage Collection involves two phases:

- Mark: In this process, the Garbage Collector marks unreferenced objects in the Heap Area.

- Sweep: In this process, the Garbage Collector cleans the object marked during the Mark process.

Garbage Collection is done automatically by the JVM at regular intervals. The Garbage Collector can also be invoked by calling the System.gc method but its execution is not guaranteed.

Java Native Interface(JNI)

The Java Native Interface loads Native Methods Libraries into the system memory. The Java Native Interface provides an interface for executing native methods (methods written in C and C++).

Native Method Libraries

The Native Method Libraries contain code that is written in native languages: C, C++ and Assembly Language. Native methods are required in cases where we need to write code that is not entirely supported by Java for instance when we need to interact with the system hardware. We add the native keyword to a method header to indicate that the implementation of the method is available in a native library. After defining a native method, we use the System.loadLibrary method to load the shared Native Library into the system memory and to make its methods available to Java. Native Libraries usually exist in the form of .so/.dll/.dylib files

Common JVM Errors

ClassNotFoundException: The Class Loader triggers a ClassNotFoundExceptionwhen the Class it is trying to load a class but does not find a definition for the specified class name. The Class Loader uses Class.forName method or the ClassLoader.loadClass method or the ClassLoader.findSystemClass method to load a class into memory.
NoClassDefFoundError: The JVM triggers this error when a class has been successfully compiled but the Class Loader cannot find the .class file at runtime.
OutOfMemoryError: The JVM triggers this error whenever it is out of memory and no more memory can be made available by the Garbage Collector.
StackOverflowError: The JVM triggers this error when a thread requires more stack memory than is available in the Stack Area.

Conclusion

In this article, we discussed the JVM and its internal components. A good understanding of how the JVM works helps us navigate common JVM related errors like the StackOverflowError when coding. Also, JVM related questions are popular during Junior and Senior level interviews for Backend Engineers.

Thank you for staying till the end. I hoped that you liked the article. Feel free to leave comments in the comment section. You can connect with me on Twitter- @ehizman_tutored and also take a look at my other articles.

Always remember to code with ❤️