Forem: Mohd Rehan

Multithreading in Java: A Beginner’s Guide to Handling Concurrency

Mohd Rehan — Sun, 28 Sep 2025 05:24:44 +0000

When I first started learning Java backend development, I hit a challenge: handling multiple user requests at the same time. For example, when two users tried to update shared data, my program sometimes returned inconsistent results. That’s when I realized I needed to understand multithreading and concurrency in Java.

What Is Multithreading?

Multithreading means running multiple tasks (threads) simultaneously inside a program. In backend systems, this is crucial for:

Handling concurrent user requests.

Improving performance.

Preventing applications from “freezing” when one task is slow.

Key Concepts in Multithreading

Thread: A lightweight unit of execution. You can create a thread by extending Thread or implementing Runnable.

Runnable: A functional interface used to define the task a thread will execute.

Synchronization: A way to control access to shared resources so multiple threads don’t cause inconsistent data.

Thread Safety: Writing code that behaves correctly even when accessed by multiple threads simultaneously.

Quick Example: Creating a Thread

class MyTask implements Runnable {
    public void run() {
        System.out.println("Task is running in: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask());
        thread.start();
    }
}

Key Takeaways

Multithreading helps backend apps handle concurrent tasks efficiently.

Always use synchronization or tools like ReentrantLock when dealing with shared resources.

Debugging multithreaded code requires patience—logs, thread dumps, and careful observation are your best friends.

👉 Have you faced tricky threading issues in your Java projects? How did you solve them? Share your story—I’d love to learn from you!

Summary only — explore the full breakdown on Hashnode →

Spring Framework Explained: Concepts, Features & Why It Matters

Mohd Rehan — Sat, 20 Sep 2025 19:54:36 +0000

When I first started working with Java, managing dependencies and modularizing code felt like juggling too many balls at once. That’s when I discovered the Spring Framework—a powerful yet lightweight framework that simplifies backend development.

What Is Spring Framework?

At its core, Spring is a Java framework for building enterprise applications. It makes code cleaner, modular, and testable through its principles of Dependency Injection (DI) and Inversion of Control (IoC).

Key Concepts You Should Know

Dependency Injection (DI) & IoC: Instead of your code manually creating objects, Spring injects them for you. This makes applications loosely coupled and easier to maintain.

Aspect-Oriented Programming (AOP): Logging, security, and transactions can be modularized into reusable aspects instead of scattered across your codebase.

Modular Architecture: Core container, beans, context, and the Spring Expression Language (SpEL) give developers fine-grained control over application structure.

Transaction Management: Spring simplifies working with relational databases and integrates smoothly with ORM tools like Hibernate and JPA.

Why Does Spring Matter?

Spring has become a cornerstone of Java backend development because it:

Reduces boilerplate code.

Increases modularity and testability.

Offers a vast ecosystem for database integration, messaging, and security.

Provides enterprise-grade features in a lightweight package.

Quick Example: Defining a Bean

@Component
public class UserService {
    public String getUser() {
        return "Hello, Spring!";
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/user")
    public String getUser() {
        return userService.getUser();
    }
}

Here, Spring takes care of wiring UserService into UserController without manual instantiation.

Takeaway

Mastering the Spring Framework’s core concepts—DI, IoC, AOP, and transaction management—gives you a strong foundation in Java backend development.

👉 Have you worked with Spring before? What’s your biggest “aha!” moment with it? Share your thoughts in the comments!

This post is a brief summary. For the full deep dive, check out the complete article on Hashnode →

A Beginner’s Guide to Exception Handling in Java

Mohd Rehan — Sat, 20 Sep 2025 19:11:21 +0000

Description: A beginner Java backend developer shares a real debugging experience with exception handling in Java. Learn how to spot errors, debug effectively, and implement clean solutions in Spring Boot applications.

Introduction: My First Real Exception Struggle

When I first started building backend applications with Java and Spring Boot, I assumed exceptions were just scary red errors that stopped my program. That illusion broke quickly when my API, which was supposed to return simple user details, crashed with a NullPointerException.

The worst part? I didn’t even know where to start. My logs looked overwhelming, my endpoint returned a 500 Internal Server Error, and I felt stuck.

This post shares how I debugged the problem step by step, the resources I relied on, and the solution that made my backend more reliable.

Step 1: The Initial Symptoms

The first sign of trouble appeared when I hit my /users/{id} endpoint. Instead of JSON, I got this error:

java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null
    at com.example.demo.service.UserService.getUser(UserService.java:25)
    at com.example.demo.controller.UserController.getUser(UserController.java:18)

👉 My application wasn’t failing silently—it was exploding loudly.

Step 2: Debugging with Logs and Tools

To understand the issue, I added a quick debug log in my service method:


public String getUser(String name) {
    System.out.println("DEBUG: Input name is -> " + name);
    return name.toUpperCase();
}

When I re-ran the request, the console printed:

**DEBUG: Input name is -> null**

💡 That’s when I realized the bug wasn’t in toUpperCase(). The issue was that my input parameter itself was null.

Step 3: Researching Java Exception Handling

Instead of wrapping everything in random try-catch blocks, I wanted a cleaner, more backend-friendly approach.

I searched “Spring Boot exception handling best practices” and came across the Spring documentation on exception handling.

From my research, I learned:

Checked exceptions must be declared or handled.
Unchecked exceptions like NullPointerException crash at runtime.
Spring Boot encourages centralized error handling using @ControllerAdvice.

Step 4: Implementing the Solution

I implemented a global exception handler to catch errors gracefully and return meaningful responses.


@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<String> handleNullPointer(NullPointerException ex) {
        return new ResponseEntity<>("Oops! A required value was missing.", HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGeneralException(Exception ex) {
        return new ResponseEntity<>("Something went wrong: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

✅ Before (Raw Error Log)

 java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null

✅ After (Improved API Response)

{
  "error": "Oops! A required value was missing."
}

Now, instead of scaring the client with stack traces, my API gives a clean and readable message.

Step 5: Key Takeaways

From this debugging journey, I learned that:

Exceptions are your debugging guide, not just annoying errors.
Logging is your first line of defense when debugging backend issues.
Centralized exception handling with @ControllerAdvice makes APIs more user-friendly.
Returning meaningful error messages helps both developers and API consumers.

Community Question

I’d love to hear from you 👇

👉 Have you faced a tricky NullPointerException or another runtime error in your Java backend projects? How did you solve it?

Sharing your debugging approaches could really help beginners like me (and maybe even save someone hours of frustration!).

JVM Architecture and Workflow: Understanding the Java Virtual Machine Internals

Mohd Rehan — Sat, 06 Sep 2025 20:52:57 +0000

Description: A beginner-friendly guide to JVM architecture and workflow with real debugging experiences. Learn how the Java Virtual Machine handles code execution, exceptions, and runtime errors step by step.

Introduction: When JVM Internals Became My Debugging Puzzle

As a beginner Java developer, I often thought of the JVM (Java Virtual Machine) as just “the thing that runs Java programs.” That illusion broke when I ran into a OutOfMemoryError: Java heap space during one of my practice backend projects.

At first, I thought I had written inefficient code. But the deeper I dug, the more I realized—the JVM itself decides how memory is allocated, how bytecode is executed, and how exceptions are managed. Understanding its internals wasn’t optional anymore.

Context & Debugging Process

Step 1: The Initial Symptoms
While processing a large dataset in Java, my application crashed with:

The error was confusing. Why did my program run fine with small inputs but fail with larger ones?

Step 2: Debugging with Logs and Tools
I enabled** Garbage Collection (GC) logs** using this JVM option:

The logs revealed that Garbage Collection was running frequently, but the heap space was still exhausted.
I then turned to the jconsole and jvisualvm tools provided with the JDK. These helped me inspect:

Heap memory usage
Thread activity
Garbage Collector behavior

Step 3: Researching JVM Internals
I started reading the Java Virtual Machine Specification and several blogs. The key realization was:

The JVM architecture (Class Loader, Runtime Data Areas, Execution Engine) controls how Java code is loaded, executed, and managed.
My issue was directly tied to heap memory management in the Runtime Data Area.

Overview of JVM Architecture and Workflow

The JVM is like a mini operating system inside your computer. It provides the environment to execute Java bytecode. Let’s break down its major components:
Image source: TechVidvan

1. Class Loader Subsystem

Loads.class files into memory.
Works in three steps: Loading, Linking, and Initialization.
Example: When you run java MyApp, the Class Loader loadsMyApp.class into memory.

2. Runtime Data Areas

The JVM divides memory into several regions:

Method Area: Stores class-level data like metadata, static variables, and method code.
Heap: Stores objects created using new. This is where I faced the OutOfMemoryError.
Stack: Each thread gets its own stack storing method frames (local variables, partial results).
PC Register: Keeps track of the current instruction.
Native Method Stack: For methods written in other languages (like C).

3. Execution Engine

Interpreter: Reads and executes bytecode instructions one by one.
JIT Compiler: Converts frequently used bytecode into native machine code for better performance.
Garbage Collector: Frees unused objects from the heap to reclaim memory.

4. Native Method Interface (JNI)
This acts as a bridge between Java code and native libraries (e.g., calling C libraries from Java).

Practical Example: JVM in Action

Consider this simple code:

Workflow inside the JVM:

Class Loader loadsJvmDemo.class.
Runtime Data Area allocates memory for the message variable in the heap.
Execution Engine interprets bytecode and runs System.out.println().
Native Method Interface calls OS-level print functionality.

Solution: Fixing My Heap Space Error
To fix theOutOfMemoryError:

Increased heap memory with JVM flags:
Optimized my code by reusing objects instead of creating unnecessary ones.
Used profiling tools (jvisualvm) to track memory leaks and unused references.

Key Takeaways

JVM architecture isn’t just theory—it directly impacts how your applications run.
Memory errors likeOutOfMemoryError can be traced back to Runtime Data Areas.
Debugging tools (jconsole, jvisualvm) are lifesavers when working with JVM issues.
Learning GC logs and JVM flags helps you fine-tune performance.

Community Question

👉 Have you ever debugged a JVM-level issue like memory leaks, GC pauses, or class loading errors? How did you solve it?

Share your story—I’d love to learn from your experience!