Creating Threads in Java with Thread Class, Runnable Interface, and Lambda

How the JVM Actually Runs Your Java Code After years of building Java services, one thing I’ve noticed is that most developers interact with the JVM every day, but rarely think about what actually happens between compiling code and running it in production. Behind the scenes, the JVM goes through several stages to safely and efficiently execute Java applications. Here’s the simplified flow 👇 1️⃣ Build The Java compiler (javac) converts .java source files into platform-independent bytecode stored in: • .class files • JAR archives • Java modules This layer is what allows Java applications to run on any platform with a JVM. 2️⃣ Load The Class Loader Subsystem dynamically loads classes when needed using the parent delegation model: • Bootstrap Class Loader → loads core JDK classes • Platform Class Loader → loads platform libraries • System Class Loader → loads application classes This mechanism improves security and prevents duplicate class loading. 3️⃣ Link Before execution, the JVM links the class through three steps: • Verify → ensures bytecode safety • Prepare → allocates memory for static variables • Resolve → converts symbolic references to direct memory references 4️⃣ Initialize The JVM assigns values to static variables and executes static initializer blocks. This step occurs only once when the class is first used. 5️⃣ Runtime Memory Areas Shared across threads: • Heap → object storage • Method Area → class metadata • Runtime Constant Pool Per thread: • JVM Stack → method frames & local variables • Program Counter (PC) → execution pointer • Native Method Stack The Garbage Collector continuously reclaims unused heap memory. 6️⃣ Execution Engine The JVM executes code using two mechanisms: • Interpreter → executes bytecode directly • JIT Compiler → compiles frequently used methods into optimized machine code Compiled code is stored in the Code Cache, improving performance over time. 7️⃣ Native Integration When Java needs system-level access, it uses JNI (Java Native Interface) to call C/C++ native libraries. 💡 What makes the JVM powerful is its hybrid execution model: • platform-independent bytecode • managed memory with garbage collection • secure class loading • runtime optimization with JIT This is why Java continues to power many large-scale backend systems. 🔍 Production insight If you’ve ever seen: • slow startup times • GC pauses • class loading conflicts • performance improving after warm-up those behaviors are directly tied to how the JVM executes and optimizes code at runtime. Understanding these internals makes debugging and performance tuning far easier. #Java #JVM #JavaDeveloper #BackendEngineering #SoftwareArchitecture #SystemDesign #PerformanceEngineering #DistributedSystems #JavaInternals

How the JVM Actually Runs Your Java Code After years of building Java services, one thing I’ve noticed is that most developers interact with the JVM every day, but rarely think about what actually happens between compiling code and running it in production. Behind the scenes, the JVM goes through several stages to safely and efficiently execute Java applications. Here’s the simplified flow 👇 1️⃣ Build The Java compiler (javac) converts .java source files into platform-independent bytecode stored in: • .class files • JAR archives • Java modules This layer is what allows Java applications to run on any platform with a JVM. 2️⃣ Load The Class Loader Subsystem dynamically loads classes when needed using the parent delegation model: • Bootstrap Class Loader → loads core JDK classes • Platform Class Loader → loads platform libraries • System Class Loader → loads application classes This mechanism improves security and prevents duplicate class loading. 3️⃣ Link Before execution, the JVM links the class through three steps: • Verify → ensures bytecode safety • Prepare → allocates memory for static variables • Resolve → converts symbolic references to direct memory references 4️⃣ Initialize The JVM assigns values to static variables and executes static initializer blocks. This step occurs only once when the class is first used. 5️⃣ Runtime Memory Areas Shared across threads: • Heap → object storage • Method Area → class metadata • Runtime Constant Pool Per thread: • JVM Stack → method frames & local variables • Program Counter (PC) → execution pointer • Native Method Stack The Garbage Collector continuously reclaims unused heap memory. 6️⃣ Execution Engine The JVM executes code using two mechanisms: • Interpreter → executes bytecode directly • JIT Compiler → compiles frequently used methods into optimized machine code Compiled code is stored in the Code Cache, improving performance over time. 7️⃣ Native Integration When Java needs system-level access, it uses JNI (Java Native Interface) to call C/C++ native libraries. 💡 What makes the JVM powerful is its hybrid execution model: • platform-independent bytecode • managed memory with garbage collection • secure class loading • runtime optimization with JIT This is why Java continues to power many large-scale backend systems. 🔍 Production insight If you’ve ever seen: • slow startup times • GC pauses • class loading conflicts • performance improving after warm-up those behaviors are directly tied to how the JVM executes and optimizes code at runtime. Understanding these internals makes debugging and performance tuning far easier. #Java #JVM #JavaDeveloper #BackendEngineering #SoftwareArchitecture #SystemDesign #PerformanceEngineering #DistributedSystems #JavaInternals

Day 16 — #100DaysJava today I learned Stream API in Java. And honestly, this one changed how I write code. ☕ Before streams, I used to write for loops for everything. Filter this, transform that, add them up. Five lines of code for something simple. Streams do the same thing in one line. Clean, readable, powerful. Here is what clicked for me today — saving this for anyone learning Java --- What is a Stream? A Stream is a pipeline. You take data, pass it through a series of operations, and get a result at the end. You are not changing the original data. You are just processing it. Think of it like a factory assembly line. Raw material goes in. Each station does one job. Final product comes out. --- The three operations I practiced today: filter() — keep only the elements that match a condition. I used it to get only even numbers from an array. Arrays.stream(arr).filter(n -> n % 2 == 0) map() — transform every element. I used it to double every number in the array. Arrays.stream(arr).map(n -> n * 2) reduce() — combine everything into one result. I used it to calculate the sum of all numbers. Arrays.stream(arr).reduce(0, (a, b) -> a + b) --- One thing that confused me first — boxed(). When you have an int array, Java creates an IntStream not a Stream of Integer objects. boxed() converts it from primitive int to Integer object so you can collect it into a List. IntStream → boxed() → Stream of Integer → collect to List Once I understood that, everything made sense. --- collect(Collectors.toList()) is how you end the stream and get your result back as a List. The stream itself does not store data — it just processes it. collect() is what actually creates the final collection. --- The real power of Streams — you can chain all of this together. Filter the evens, double them, collect into a list. One line. No loop. No temporary variables. This is exactly how modern Java code looks in real companies. --- 16 days in. Every day something new clicks. 💪 Day 1 ...................................... Day 16 Are you using Streams in your daily Java work? What is the most useful stream operation you use? Drop it below! 🙏 #Java #StreamAPI #FunctionalProgramming #100DaysOfJava #JavaDeveloper #LearningInPublic #BackendDevelopment #100DaysOfCode #CleanCode #ModernJava

☕ Core JAVA Notes — Complete Study Guide 📖 About the Document A thorough, beginner-to-intermediate Core Java study guide spanning 130 pages, packed with clear explanations, syntax breakdowns, real code examples, and comparison tables. Scanned and formatted for students and aspiring Java developers. 🚀 🏗️ What's Inside? 🔷 Chapter 1 — Java Introduction ➤ What is Java? — A high-level, object-oriented, platform-independent language by Sun Microsystems (now Oracle), born in 1995 ➤ The legendary "Write Once, Run Anywhere" (WORA) principle powered by the JVM ➤ Key features: Platform Independence, OOP, Robustness, Multithreading, Rich Standard Library ➤ Where Java is used: Web Development, Mobile Apps (Android), Enterprise Systems ➤ First program: Hello, World! 👋 🔶 Chapter 2 — OOP Concepts (Object-Oriented Programming) ➤ Classes & Objects — Blueprints and instances of real-world entities ➤ POJO (Plain Old Java Object) — private fields, constructors, getters/setters, toString/hashCode ➤ Constructors — Default, Parameterized, this() and super() keywords ➤ Inheritance — extends keyword, parent-child relationships, super calls ➤ Polymorphism — Method Overloading & Overriding ➤ Abstraction — Abstract classes & Interfaces ➤ Encapsulation — Access modifiers: public, private, protected 🟡 Chapter 3 — Core Language Features ➤ Data Types, Variables, Operators, Control Statements (if, switch, loops) ➤ Arrays — single/multi-dimensional, iteration patterns ➤ Exception Handling — try, catch, finally, throws, custom exceptions 🟢 Chapter 4 — String Handling ➤ String class — immutable, pool concept ➤ Key methods: length(), charAt(), substring(), equals(), compareTo(), replace() ➤ StringBuilder — mutable, faster, single-threaded environments ➤ StringBuffer — mutable, thread-safe for concurrent modifications 🔵 Chapter 5 — Collections Framework ➤ ArrayList vs Array — dynamic sizing, java.util.ArrayList ➤ List, Set, Map interfaces — HashMap, HashSet, LinkedList ➤ Iterating with for, for-each, and Iterator ➤ Java Collections = store & manipulate groups of objects efficiently 📦 #CoreJava #Java #JavaProgramming #OOPConcepts #LearnJava #JavaForBeginners #ObjectOrientedProgramming #JVM #WORA #JavaCollections #StringHandling #StringBuilder #Inheritance #Polymorphism #Encapsulation #Abstraction #LambdaExpressions #AnonymousClass #Multithreading #JavaInterviewPrep #PlacementPreparation #ComputerScience #CodingNotes #ProgrammingLanguage #SoftwareDevelopment #JavaDeveloper #BackendDevelopment #TechNotes #StudyMaterial #CodeWithJava

☕ How Java Actually Works — from source code to running application. Most developers use Java daily without knowing this. After 10+ years of building enterprise Java systems, understanding what happens under the hood has made me a dramatically better engineer. Let me walk through every stage 👇 📝 Stage 1 — Source You write Java code in your editor — IntelliJ, VS Code, Eclipse. That code is saved as a .java source file. Human-readable. Platform-specific to nothing yet. This is where it all begins. ⚙️ Stage 2 — Compile The Java Compiler (javac) transforms your .java source file into Bytecode — a .class file. This is the magic of Java's "Write Once Run Anywhere" promise. The bytecode is not native machine code — it's an intermediate language that any JVM on any platform can understand. Windows, Linux, Mac — same bytecode runs everywhere. 📦 Stage 3 — Artifacts The compiled .class files are packaged into artifacts — JAR files, modules, or classpath entries. In enterprise projects I've shipped across Bank of America and United Health, Maven and Gradle manage this — producing versioned artifacts deployed to Nexus or AWS CodeArtifact repositories. 📂 Stage 4 — Load The Class Loader loads .class files, JARs, and modules into the Java Runtime Environment at runtime. Three built-in class loaders handle this — Bootstrap, Extension, and Application. Understanding class loading has helped me debug NoClassDefFoundError and ClassNotFoundException in production more times than I can count. 🔍 JVM — Verify Before executing a single instruction, the JVM Verifier checks the bytecode for correctness and security violations. No invalid memory access. No type violations. No corrupted bytecode. This is one reason Java is inherently safer than languages with direct memory management. ▶️ Stage 5 — Execute — Interpreter + JIT Compiler This is where performance gets interesting. The JVM first Interprets bytecode line by line — fast startup, moderate throughput. Simultaneously it monitors execution and identifies hot paths — code that runs frequently. Those hot paths are handed to the JIT (Just-In-Time) Compiler which compiles them to native machine code stored in the Code Cache. 🏃 Stage 6 — Run The JVM runs a mix of interpreted bytecode and JIT-compiled native code — balancing startup speed with peak performance. Standard Libraries (java.* / jdk.*) provide everything from collections to networking to I/O throughout execution. #Java #c2c #opentowork #c2h #JVM #CoreJava #JavaDeveloper #SpringBoot #JVMPerformance #FullStackDeveloper #OpenToWork #BackendDeveloper #Java17 #HiringNow #EnterpriseJava #SoftwareEngineer #JITCompiler #JavaInterview #CloudNative #Microservices #TechEducation #Programming

Day 11 ⛰️ Java Practice: Check if an Array is a Mountain Array While practicing Java, I came across an interesting array problem: A Mountain Array means: -> Elements first strictly increase -> Reach a peak -> Then strictly decrease -> And the array length must be greater than 2 Example: {5,7,10,14,12,4,2,1} ✅ Mountain Array To solve this, Instead of using extra variables or collections, I solved it using a single index and two while loops — one for climbing up and one for coming down. This approach keeps the logic simple and efficient. ================================================= // Online Java Compiler // Use this editor to write, compile and run your Java code online import java.util.*; class Main {   public static void main(String[] args) {           int a[]={5,7,10,14,12,4,2,1};           System.out.println(mountainArrayCheck(a));   }       public static boolean mountainArrayCheck(int a [])   {     //1).Length of the Array must be greater than 2      if(a.length<3)     {       return false ;     }           int i=0;           //2).Elements must be increasing order !!!     while(i+1<a.length && a[i]<a[i+1])     {       i++;     }           //2).When we reached at peack elements must be decreasing order !!!     while(i+1<a.length && a[i]>a[i+1])     {       i++;     }           if(a.length-1 ==i)     {       return true ;     }     else     {       return false ;     }       } } output : true #AutomationTestEngineer #Selenium #Java #InterviewPreparation #CodingPractice

Day 65 of Sharing What I’ve Learned 🚀 Creating Threads in Java — Turning Concepts into Execution After building a clear understanding of programs, processes, and threads, the next step was to move from theory to practice — how threads are actually created and used in Java. Understanding what a thread is is important. But knowing how to create and control it is where things start getting real. 🔹 Two Ways to Create Threads in Java Java provides two primary ways to create threads: 1️⃣ Extending the Thread class Here, we create a class that extends Thread and override the run() method. class MyThread extends Thread { public void run() { System.out.println("Thread is running..."); } } public class Main { public static void main(String[] args) { MyThread t1 = new MyThread(); t1.start(); // starts a new thread } } 👉 start() is important — it creates a new thread and calls run() internally. 2️⃣ Implementing the Runnable interface This is the more flexible and commonly used approach. class MyRunnable implements Runnable { public void run() { System.out.println("Thread using Runnable..."); } } public class Main { public static void main(String[] args) { Thread t1 = new Thread(new MyRunnable()); t1.start(); } } 👉 This approach is preferred because Java doesn’t support multiple inheritance, but it allows implementing multiple interfaces. 🔹 Key Difference Thread → Direct but less flexible Runnable → More scalable and widely used in real-world applications 🔹 Important Observation Creating a thread is not just about writing run() 👉 It’s about understanding how execution flow changes run() → normal method call (no new thread) start() → creates a new thread (parallel execution) 🔹 Simple Perspective Thread creation = defining a task start() = actually running it concurrently 🔹 Why This Matters This is where applications start becoming powerful: 👉 Multiple tasks can run independently 👉 Better performance and responsiveness 👉 Foundation for advanced concepts like thread synchronization and concurrency 🔹 My Realization Earlier, execution felt linear — one step after another. Now it’s clear that: 👉 Execution doesn’t have to wait 👉 Tasks can run side by side 👉 Efficiency comes from how we structure execution This is just the next layer — Up next: controlling threads and managing their lifecycle. #Java #Multithreading #Programming #JavaDeveloper #100DaysOfCode #DeveloperJourney #Day65 Grateful for guidance from TAP Academy Sharath R kshitij kenganavar

After 14 years in Java backend, I realized something uncomfortable. I had never consciously used WeakReference, SoftReference, or PhantomReference in production. And yet — I was benefiting from them every single day without knowing it. Let me explain. 👇 ───────────────────────── A few years back, our service started leaking memory. Slowly. Silently. The heap grew. GC ran more. Latency spiked. Classic signs. After hours of heap dumps and profiling, we found it. A listener registry. Objects were no longer in use. But GC couldn't clean them. Root cause? Strong references in a static listener list. Fix? Switched to WeakReference. The leak disappeared. That day, I stopped treating reference types as "theoretical JVM knowledge." ───────────────────────── Here's what I wish I had understood earlier: 🔴 Strong Reference Object obj = new Object(); GC never touches it. As long as this reference exists, the object lives. → The silent cause of most memory leaks in long-running services. 🟡 Soft Reference SoftReference<byte[]> cache = new SoftReference<>(data); GC evicts only under memory pressure. → Historically used for caches. Modern systems now prefer explicit eviction strategies (e.g., Caffeine, Guava Cache) — more predictable under load. 🟠 Weak Reference WeakReference<User> ref = new WeakReference<>(user); GC collects at the next cycle if no strong reference exists. → Ideal for listener registries, observer patterns, and WeakHashMap. → This is what fixed our leak. 🟤 Phantom Reference PhantomReference<Object> phantom = new PhantomReference<>(obj, queue); The object is already gone when you get notified. → Used for native/off-heap resource cleanup. In modern Java (9+), the Cleaner API is the cleaner alternative. ───────────────────────── The mental model that stuck with me: Strong  → "I own this. Never release." Soft   → "Keep if memory allows." Weak   → "Release when no one else cares." Phantom → "Notify me when it's truly dead." ───────────────────────── If you've never used these explicitly, you're not alone. But knowing when to reach for them? That's where senior engineering starts. Have you ever debugged a memory leak like this? What was the root cause? Drop it below 👇 — I'd genuinely love to compare notes. #Java #JVM #GarbageCollection #BackendEngineering #JavaDeveloper #JavaPerformance #SoftwareEngineering #Performance

🤔 Ever wondered how Java handles multiple threads safely? Let’s break it down in a simple way 👇 🚀 **Synchronized vs Atomic Classes in Java — Explained Simply Multithreading is powerful, but handling shared data safely is critical. Let’s break it down 👇 🔒 What is `synchronized`? A keyword in Java used to control access to shared resources. ✔ Ensures only one thread executes at a time (Mutual Exclusion) ✔ Prevents race conditions Example: public synchronized void increment() {   count++; } 🔑 How it works? * Every object has an **Intrinsic Lock (Monitor)** * Thread acquires lock → executes → releases lock * Other threads must wait Automatic: When you use the synchronized keyword, Java handles the locking and unlocking for you behind the scenes. 💡 Think: One door, one key — whoever holds the key gets access --- ### 🧠 Guarantees ✔ Mutual Exclusion(Only one thread can access a shared resource at a time) ✔ Visibility (changes visible to other threads) ✔ Ordering (Happens-Before) ⚙️ Memory Visibility (Internals) Based on Java Memory Model 1️⃣ Write → Store Barrier → Writing updated values from a thread’s local CPU cache to the shared main memory (RAM) 2️⃣ Read → Load Barrier → Ensure fresh values are read from main memory 💡 Ensures threads don’t read stale data from CPU cache ⚡ What is `AtomicInteger`? A class from: java.util.concurrent.atomic ✔ Thread-safe without locks ✔ Uses **CAS (Compare-And-Swap)** + memory barriers Example: AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); 🔄 CAS Logic If current value == expected → update Else → retry Key Methods get()         // read value set()         // update value incrementAndGet()   // ++count getAndIncrement()   // count++ compareAndSet(a, b)  // CAS operation Example Thread-1: expected = 0 → update to 1 ✅ Thread-2: expected = 0 → fails ❌ (value already changed)       retries → succeeds later 📦 Atomic Package Categories * **Primitive** → AtomicInteger, AtomicLong * **Reference** → AtomicReference, Stamped, Markable * **Array** → AtomicIntegerArray * **Field Updaters** → Fine-grained updates * **High Concurrency** → LongAdder, DoubleAdder 🚀 Why `LongAdder`? (Java 8) Problem with Atomic: ❌ High contention ❌ Too many CAS retries Solution: ✔ Split into multiple counters AtomicInteger → [ 0 ] ❌ ← all threads update here ❌ (bottleneck) LongAdder   → [1][2][3][4]  ← threads distributed ✅ ✔ Better performance under heavy load ✅ When to Use **Use synchronized** ✔ Complex operations ✔ Multiple variables **Use Atomic** ✔ Counters ✔ Simple updates **Use LongAdder** ✔ High concurrency systems (metrics, counters) 🎯 Final Takeaway 👉 Use synchronized for safety. 👉 Atomic for performance 👉LongAdder for scalability #Java #Multithreading #Concurrency #CoreJava #InterviewPrep

🚀 Mastering Java Exception Handling & Propagation! 🚀 Today was an intensive deep dive into how Java manages those "unusual events" that occur during runtime—Exceptions. Here’s a breakdown of what I learned about keeping programs running smoothly instead of letting them crash abruptly! 💡 What is an Exception? An Exception is an unusual event that occurs during a program's runtime, often due to faulty user input, which leads to abrupt termination. Our goal as developers is to handle these gracefully to ensure normal termination. 🔍 3 Ways to Get Exception Information: When an exception object is generated, we have three main ways to see what went wrong: 1) Printing the Reference (e): Provides the Type of exception and the Reason (Description). This works because the toString method is overridden in the Exception class. 2) e.getMessage(): Provides only the Reason/Description why the exception occurred. 3) e.printStackTrace(): The "complete description." It shows the Type, the Reason, and the exact Location (method and line number) where it occurred. 🌊 Exception Propagation If an exception isn't handled where it occurs, it propagates (travels) up the call stack to the caller method. If no one handles it, the Default Exception Handler takes over, printing the error and abruptly terminating the program. 🛠️ The 3 Strategies for Handling: The sources identify three primary ways to manage these situations: ✅ Try-Catch: Handling it directly at the source. This is considered the best practice. 🔄 Rethrowing: Catching the exception, performing some action, and then using the throw keyword to pass it back to the caller. 🦆 Ducking: "Escaping" or dodging the exception. You don't use a try-catch block; instead, you use the throws keyword in the method signature to warn the caller they must handle it. 💻 Coding Example: The Power of finally One of the most important keywords is finally. This block compulsory executes whether an exception is thrown or not—perfect for closing connections!. public class ExceptionDemo { // Ducking the exception using 'throws' public void calculate() throws ArithmeticException { try { int a = 100, b = 0; int c = a / b; // Risky code! System.out.println("Result: " + c); } catch (ArithmeticException e) { System.out.println("Reason: " + e.getMessage()); throw e; // Rethrowing the exception object reference } finally { // This ALWAYS runs, ensuring normal cleanup System.out.println("Connection Terminated Safely."); } } } 🗝️ Key Takeaway Polymorphism is at the heart of this! Since Exception is the parent class of all exceptions, a parent reference can catch any child exception object (loose coupling). #Java #Coding #BackendDevelopment #ExceptionHandling #ProgrammingTips #LearningJourney #TapAcademy #HarshitT