DEV Community: Mamta Leel

Thread Internal Memory Allocation in Java | Thread vs Process

Mamta Leel — Sat, 16 Aug 2025 12:03:25 +0000

When learning multithreading in Java, it’s important to first understand how processes and threads work, and how the JVM allocates memory to manage them.

🔹 Process vs Thread

Process

A process is an instance of a program in execution.
Each process has its own memory space (code, data, heap, stack).
The Operating System (OS) allocates resources like CPU time, memory, and file handles to each process.

Example: Running java Main starts the JVM as a process.

Thread

A thread is the smallest unit of execution within a process (sometimes called a lightweight process).
A process can contain multiple threads.
When a process starts, it begins with one main thread.
Threads inside a process run concurrently, improving performance.
Each thread has its own stack, program counter, and name, but shares the process’s code, data, and heap.

🧑‍💻 Example: Current Thread in Java

public class Main { public static void main(String[] args) { System.out.println("Running current thread: " + Thread.currentThread().getName()); } }

Output:

Running current thread: main

👉 By default, the JVM starts your program with the main thread.

🧩 JVM Instance & Memory Allocation

When you run a Java program, here’s what happens step by step:

Step 1: Compilation

javac Main.java

Source code (.java) → Compiled into bytecode (.class)
Bytecode is platform-independent, runs on the JVM.

Step 2: Execution

java Main

OS creates a process for the JVM.
Inside this process, a JVM instance is created.
JVM uses an interpreter/JIT compiler to convert bytecode → machine code.

🗂 JVM Memory Segments

_ Code Segment (Method Area)_

Stores compiled bytecode/machine code.
Shared across all threads.

_ Data Segment_

Stores global and static variables.
Shared by all threads → needs synchronization.

_ Heap Memory_

Stores objects created with new.
Shared across all threads.

Stack Memory (per thread)

Each thread has its own stack.
Stores method calls, local variables, and references.

_ Registers (per thread)_

CPU registers store the program counter.
Used during context switching between threads.

⚙️ Who Executes Threads?

The OS scheduler or JVM thread scheduler is responsible for:
Loading thread registers into the CPU.
Managing execution order.
Handling context switching.
Ensuring efficient parallel execution.

✅ Summary

A process is a running program with its own memory.
A thread is the smallest execution unit inside a process.
JVM memory is divided into code, data, heap, stack, and registers.
Threads share code, data, and heap, but each has its own stack and registers.
This structure allows efficient execution and multithreading in Java.

🚀 With this foundation, you’re ready to dive deeper into Java concurrency APIs, thread pools, and synchronization techniques!

DynamoDB Part-01- 🚀 Guide to Running DynamoDB Locally

Mamta Leel — Mon, 03 Mar 2025 14:40:30 +0000

Hey Dev Community! 👋
To install dynamoDB locally follow the below steps.

🛠️ Step 1: Download DynamoDB
Get DynamoDB Local for free from the official sources:

🖥️ Mac/Linux → Download tar.gz
🖥️ Windows → Download .zip

🔧 Step 2: Install AWS CLI
To easily view tables and data in a GUI, install the AWS CLI.
here

📂 Step 3: Extract and Run DynamoDB
1️⃣ Extract the downloaded .zip file.
2️⃣ Navigate to the directory containing DynamoDBLocal.jar.
3️⃣ Run the following command:
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb -dbPath C:/dynamodb/data

💡 Important: Ensure that the dynamodb/data directory exists in the C:/ drive. If not, create it using:
mkdir C:/dynamodb/data

🔑 Step 4: Configure AWS Credentials for Local Use
Set up AWS credentials for local development using:
aws configure

📋 Step 5: Verify Tables
To check the available tables, run:
aws dynamodb list-tables --endpoint-url http://localhost:8000

🎉 Your DynamoDB is running locally and now add a backend service and hit queries. or you can use terminal too to test it.
Your DynamoDB is running port by default on 8000, you can change with -port [port you want to keep]. and then check the data.

In the next part, we’ll explore how to integrate DynamoDB with a Spring Boot application! 🚀

Upgrading Your Application to Java 17: A Step-by-Step Guide for Developers

Mamta Leel — Tue, 22 Oct 2024 14:27:17 +0000

Hello, Developers!

In this blog post, I’ll guide you through the process of updating your existing application to Java 17 (LTS). This upgrade can enhance your application's performance and security while providing access to the latest language features. Let’s dive into the steps!

Step 1: Download a Compatible IDE

First, ensure you’re using an Integrated Development Environment (IDE) that supports Java 17 and above. For this guide, I recommend using IntelliJ IDEA version 2021.3.2 or later.

Step 2: Update Build Tools

If your project uses Maven or Gradle, update to a version compatible with Java 17. For instance, I used Maven version 3.9.9 during my upgrade process.

Step 3: Download JDK 17

Next, download and install the Java Development Kit (JDK) 17 from the official Oracle website or your preferred distribution.

Step 4: Set Up Environment Variables

Update your environment variables to reflect the new Java installation.

JAVA_HOME: Set it to the path of your JDK 17 installation.
MAVEN_HOME: Update this to point to your latest Maven installation.
If needed, set JAVA_17_HOME and M2_HOME to these respective paths.

Step 5: Update cacerts

If your application relies on the cacerts file located in jre/lib/security, ensure you copy the relevant cacerts file from your old JRE to the new JDK 17 directory.

Step 6: Configure Your Project Settings

Open your existing service in IntelliJ and check the project settings:

Navigate to

File > Settings > Build, Execution, Deployment > Build Tools > Maven.

Enable Use Maven Wrapper to avoid dependency loading issues.

Step 7: Update SDK and Language Level

Go to File > Project Structure and perform the following:

Update the SDK to version 17.
Set the project’s language level to 17 (this may include options like "17-Sealed Type,Always Strict,..").

Step 8: Build Your Application

Run the following command to clean and build your application:

mvn clean install -Djava_version=17

Step 9: Address Deprecated Dependencies

As you upgrade, some dependencies may be deprecated or relocated. Review your pom.xml and update any affected libraries. Below are some of the latest versions of common dependencies you might consider:

<lombok.version>1.18.30</lombok.version>
<httpclient.version>4.5.13</httpclient.version>
<cucumber.version>7.18.0</cucumber.version>
<spring-cloud.version>2021.0.6</spring-cloud.version>
<jackson.version>2.17.2</jackson.version>
<assertj-core.version>3.25.3</assertj-core.version>
<rest-assured.version>5.4.0</rest-assured.version>
<dom4j.version>2.4.3</dom4j.version>
<jacoco-maven-plugin.version>0.8.8</jacoco-maven-plugin.version>

Make sure to update your pom.xml dependencies to the latest compatible versions.

Step 10: Final Package Updates

Lastly, check for any other packages that may need updating to ensure compatibility with Java 17. Some packages have been migrated to new packages. Here’s a list of those changes:

javax.* → jakarta.*
java.activation → jakarta.activation
java.xml.ws.annotation → jakarta.annotation-api
java.transaction → jakarta.transaction-api
java.xml.bind → jakarta.xml.bind-api
java.xml.ws → jakarta.xml.ws-api

Conclusion
Upgrading to Java 17 can significantly improve your application's capabilities and maintainability. By following these steps, you’ll be well on your way to harnessing the full potential of the latest Java features.

If you have any questions or need further assistance, feel free to leave a comment below!

Happy coding!