Java Exception Handling, Multithreading & DSA Practice

🚀 Understanding Java Multithreading – Simplified Multithreading is one of those concepts that feels complex… until you visualize it right. 👇 Here’s a breakdown based on the diagram: 🔹 Main Thread (The Starting Point) Every Java program begins with the main thread. 👉 It executes the main() method and acts as the parent of all other threads. 👉 From here, you can create additional threads to perform tasks in parallel. 👉 If the main thread finishes early, it can affect the lifecycle of other threads (unless managed properly). 🔹 JVM & Threads A Java application runs inside the JVM, where multiple threads execute simultaneously. Each thread has its own stack (local variables, method calls), but they all share the same heap memory. This shared access is powerful—but also risky. 🔹 Thread Lifecycle Threads don’t just “run”—they move through states: ➡️ New → Runnable → Running → Waiting/Blocked → Terminated Understanding this flow helps debug performance and deadlock issues. 🔹 Thread Scheduling & CPU The thread scheduler decides which thread gets CPU time. With time slicing, multiple threads appear to run at once—even on a single core. 🔹 The Real Challenge: Concurrency Issues Without synchronization → ❌ Race conditions With synchronization → ✅ Data consistency When multiple threads access shared data, proper locking (synchronized, monitors) becomes critical to avoid bugs that are hard to reproduce. 💡 Key Takeaway: Multithreading isn’t just about speed—it’s about writing safe, efficient, and scalable applications. If you're learning Java, mastering this concept is a game-changer. 🔥 #Java #Multithreading #Concurrency #SoftwareEngineering #JVM #Programming #TechLearning

🔥 Serialization & Deserialization in Java A very important concept for saving and transferring objects in Java 👇 🔹 1. Serialization 👉 Converting an object into a byte stream so it can be saved to a file or sent over a network. ✔ Used for file storage ✔ Used in networking ✔ Implemented using "Serializable" interface 🔹 2. Deserialization 👉 Converting the byte stream back into an object. ✔ Restores object state ✔ Used when reading from file/network 💻 Simple Example: // Serialization ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.txt")); oos.writeObject(s1); oos.close(); // Deserialization ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.txt")); Student s2 = (Student) ois.readObject(); ois.close(); 📌 Key Points: ✔ Class must implement "Serializable" ✔ Use "ObjectOutputStream" → write object ✔ Use "ObjectInputStream" → read object ✔ "transient" keyword → skip fields 📦 Real-Life Analogy: Serialization = Packing an object into a box Deserialization = Unpacking it back 💡 Pro Tip: Always define "serialVersionUID" to avoid version mismatch issues 📌 Final Thought: "Serialization turns objects into data. Deserialization brings them back to life." #Java #Serialization #Deserialization #JavaDeveloper #Programming #Coding #InterviewPrep #BackendDevelopment

Ever wondered if Java’s checked exceptions can be… bypassed? I explored an interesting approach using generics to influence how checked exceptions are treated by the compiler. Here’s the interesting part: catch (Exception e) { Task.<RuntimeException>throwAs(e); } At compile time: The compiler believes we are throwing a RuntimeException (unchecked), so it doesn’t force us to handle or declare it. At runtime: Due to type erasure, the JVM simply throws the original exception which can still be a checked exception like InterruptedException. The trick lies in this method: @SuppressWarnings("unchecked") public static <T extends Throwable> void throwAs(Throwable t) throws T { throw (T) t; } This works because: • Generics are erased at runtime • Checked exceptions are enforced only by the compiler So effectively: → We bypass Java’s checked exception mechanism → Without breaking any JVM rules This pattern is often called a “Sneaky Throw” and is even used internally by tools like Lombok (@SneakyThrows). Not something to use casually in production, but a great way to understand how Java’s type system and exception handling really work under the hood. #Java #Programming #Generics #ExceptionHandling

Garbage Collection in Java – How JVM Cleans Memory 🧹 In C/C++, memory must be freed manually. In Java? The JVM handles it automatically using Garbage Collection. How it works: ▸ GC runs automatically inside the JVM ▸ Identifies objects with NO active references ▸ Removes them from Heap memory ▸ Frees space for new object allocation JVM Heap Structure: 1️⃣ Young Generation → New objects are created here → Minor GC runs frequently (fast cleanup) 2️⃣ Old Generation → Long-living objects move here → Major/Full GC runs here (slower & expensive) 3️⃣ Metaspace (Java 8+) → Stores class metadata → Replaced PermGen Can we force GC? ▸ "System.gc()" only suggests the JVM to run GC ▸ Execution is NOT guaranteed Behind the scenes: → JVM uses different GC algorithms like: ▸ Serial GC ▸ G1 GC (default in modern JVMs) ▸ ZGC / Shenandoah (low-latency collectors) Best Practices: → Avoid creating unnecessary objects → Don’t rely on "System.gc()" → Close resources using try-with-resources → Nullify references only when necessary (e.g., large unused objects) #Java #SpringBoot #GarbageCollection #JVM #JavaDeveloper #BackendDeveloper

Modern Java quietly made the Visitor pattern relevant again. Sealed classes changed the tradeoffs. It might be time to revisit Visitor. I wrote about why Visitor still makes sense if you're using Java 17–20: https://lnkd.in/dPkpgqtb

💡 𝗛𝗼𝘄 𝗝𝗮𝘃𝗮 𝗪𝗼𝗿𝗸𝘀 𝗨𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗛𝗼𝗼𝗱 — 𝗙𝗿𝗼𝗺 𝗖𝗼𝗱𝗲 𝘁𝗼 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 Ever wondered what happens when you run a Java program? Here’s a simple breakdown: 1️⃣ 𝗪𝗿𝗶𝘁𝗲 𝗖𝗼𝗱𝗲 You write Java source code in a `.java` file. 2️⃣ 𝗖𝗼𝗺𝗽𝗶𝗹𝗲 The Java compiler (`javac`) converts `.java` file into **bytecode** (`.class` file). 3️⃣ 𝗖𝗹𝗮𝘀𝘀 𝗟𝗼𝗮𝗱𝗲𝗿 JVM loads the `.class` bytecode into memory. 4️⃣ 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲 𝗩𝗲𝗿𝗶𝗳𝗶𝗲𝗿 Checks for security issues and ensures code follows Java rules. 5️⃣ 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 JVM executes bytecode using: • Interpreter (line by line execution) • JIT Compiler (converts to native machine code for faster performance) 👉 Flow: Java Code → Compiler → Bytecode → JVM → Machine Code → Output ✨ This is why Java is platform independent: "Write Once, Run Anywhere" #Java #JVM #Programming #JavaDeveloper #Coding #SoftwareDevelopment #TechLearning

🚀 100 Days of Java Tips — Day 11 Tip: Use "var" for cleaner code (Java 10+) Java introduced "var" to make code less verbose and more readable. Instead of writing: String name = "Aishwarya"; You can write: var name = "Aishwarya"; The compiler automatically understands the type based on the value. Why it matters: • Reduces boilerplate code • Improves readability in simple cases • Helps you focus more on logic than type declarations But don't overuse it: If the type is not obvious, avoid using "var" Overusing it can make code confusing and harder to maintain Best practice: Use "var" where the type is clear from the right-hand side Clean code is not about writing less It's about writing code that others can understand easily Do you use "var" in your projects? 👇 #Java #JavaTips #Programming #Developers #CleanCode #BackendDevelopment

🔥 Day 20: Thread Lifecycle in Java Understanding thread lifecycle is key to mastering multithreading 👇 🔹 What is Thread Lifecycle? 👉 It defines the different states a thread goes through during its execution. 🔹 Thread States in Java 1️⃣ NEW 👉 Thread is created but not started Thread t = new Thread(); 2️⃣ RUNNABLE 👉 Thread is ready or running (after start()) 3️⃣ BLOCKED 👉 Waiting to acquire a lock (synchronization) 4️⃣ WAITING 👉 Waiting indefinitely for another thread (e.g., wait()) 5️⃣ TIMED_WAITING 👉 Waiting for a specific time (e.g., sleep(1000)) 6️⃣ TERMINATED 👉 Thread execution is completed 🔹 Simple Example class MyThread extends Thread { public void run() { System.out.println("Thread Running..."); } } public class Main { public static void main(String[] args) { MyThread t = new MyThread(); System.out.println(t.getState()); // NEW t.start(); System.out.println(t.getState()); // RUNNABLE } } 🔹 Lifecycle Flow NEW → RUNNABLE → (BLOCKED / WAITING / TIMED_WAITING) → TERMINATED 🔹 Key Points ✔ start() → moves thread to RUNNABLE ✔ sleep() → TIMED_WAITING ✔ wait() → WAITING ✔ Lock issues → BLOCKED 💡 Pro Tip: Thread state may change quickly — don’t rely on exact timing in real systems. 📌 Final Thought: "Threads have a life cycle — understanding it helps you control execution." #Java #Multithreading #ThreadLifecycle #Programming #JavaDeveloper #Coding #InterviewPrep #Day20

Day 9 of Java I/O Journey Today I explored the difference between Byte Streams and Character Streams in Java. 🔹 Byte Streams • Work with raw binary data • Used for images, videos, and non-text files • Classes: InputStream, OutputStream, FileInputStream, FileOutputStream 🔹 Character Streams • Work with text data • Handle characters using encoding (UTF-16 internally) • Classes: Reader, Writer, FileReader, FileWriter 💡 Key Insight: Choosing the right stream depends on the type of data you are working with. ✔ Binary data → Use Byte Streams ✔ Text data → Use Character Streams Also practiced basic examples of reading and writing using both types. Step by step, concepts are getting clearer and more practical ⚡ #Java #JavaIO #Programming #Coding #Developer #SoftwareDevelopment #LearningInPublic #100DaysOfCode #CodeNewbie #DevelopersLife #TechLearning #CodingJourney #JavaDeveloper #BackendDevelopment #ComputerScience #Hariom #HariomKumar #Hariomcse

Day 11/100 – Java Practice Challenge 🚀 Continuing my #100DaysOfCode journey with another important Java concept. 🔹 Topic Covered: Compile-time vs Runtime Polymorphism 💻 Practice Code: 🔸 Compile-time Polymorphism (Method Overloading) class Calculator { int add(int a, int b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } } 🔸 Runtime Polymorphism (Method Overriding) class Animal { void sound() { System.out.println("Animal sound"); } } class Cat extends Animal { @Override void sound() { System.out.println("Cat meows"); } } public class Main { public static void main(String[] args) { // Compile-time Calculator c = new Calculator(); System.out.println(c.add(10, 20)); System.out.println(c.add(10, 20, 30)); // Runtime Animal a = new Cat(); a.sound(); } } 📌 Key Learnings: ✔️ Compile-time → method decided at compile time ✔️ Runtime → method decided at runtime ✔️ Overloading vs Overriding difference 🎯 Focus: Understanding how Java resolves method calls 🔥 Interview Insight: Difference between compile-time and runtime polymorphism is one of the most frequently asked Java interview questions. #Java #100DaysOfCode #MethodOverloading #MethodOverriding #Polymorphism #JavaDeveloper #Programming #LearningInPublic