Leopoldo Medeiros’ Post

Double-checked locking in Java looks correct… but it’s broken without volatile. Why? Because of instruction reordering by the JVM. Object creation is NOT atomic: 1. Allocate memory 2. Assign reference 3. Initialize object Steps 2 and 3 can be reordered. So another thread might get a reference to an object that is not fully initialized ❌ This leads to subtle and hard-to-debug bugs. Fix: Use volatile with double-checked locking. private static volatile Singleton instance; Lesson: Concurrency bugs don’t fail fast — they fail silently. #Java #Multithreading #Concurrency #Backend #SoftwareEngineering #JVM

🔥 Hot take: Thread pools are becoming legacy thinking in Java. For years, we’ve been juggling: → Limited thread pools → High memory usage → Complex async code And calling it “scalable” 😅 Then comes Java 21 + Virtual Threads (Project Loom)… ⚡ Thousands (even millions) of lightweight threads ⚡ Near-zero overhead ⚡ Write simple, blocking code — still scale like crazy No more over-engineering with reactive frameworks just to handle concurrency. Sometimes, the best innovation isn’t adding complexity… it’s removing it. If you haven’t explored Virtual Threads yet, now is the time. #Java21 #ProjectLoom #VirtualThreads #Concurrency #BackendDevelopment #SoftwareEngineering #TechTrends

Mastering Virtual Threads in Java 21 – The Game-Changer for Ultra-High-Throughput Backend Services 🔥 As a Java Developer who has scaled systems to handle 500K+ concurrent requests, I can confidently say: Virtual Threads (Project Loom) is the biggest revolution in Java concurrency since the introduction of the Fork/Join framework. Gone are the days of thread-pool hell, context-switching overhead, and “one thread per request” limitations. Pro tip from production trenches: Combine Virtual Threads with Structured Concurrency (Java 22 preview) and you get automatic cancellation + clean error handling – the holy grail of backend engineering. Who else is already running Virtual Threads in production? Drop your experience or biggest challenge in the comments 👇 I reply to every single one. #Java #Java21 #VirtualThreads #SpringBoot #Microservices #BackendDevelopment #HighScaleSystems #JavaPerformance #JavaDeveloper #BackendEngineer

Spring Boot Circular Proxy Issue — Advanced trap 🤯 Even if you FIX circular dependency… Spring may still create proxies internally. 👉 This can lead to: ❌ Unexpected behavior ❌ Method not executing correctly 💡 Why? Spring uses AOP proxies (JDK / CGLIB) ⚠️ Problem: Internal method calls bypass proxy Example: Method A → calls Method B internally 👉 AOP (like @Transactional) won’t apply 🔥 Solution: ✔ Move logic to another bean ✔ Avoid internal method calls 👉 This is why some transactions “don’t work” Understanding proxies = senior-level Spring knowledge 💯 #SpringBoot #Java #AOP

Java 26 introduces warnings for illegal final field mutation. Future releases will deny it by default. Start migrating now: inventory with debug, enforce in CI. https://lnkd.in/d8Kcz7m5 ← Learn how to avoid breakage & unlock safer JVM optimizations with Babneet Singh! #Java26 #DevOps #Java

Took a simple one today: replace spaces with "%20" Looks trivial until you remember… Java strings don’t change. So instead of “fixing” the string, you just build a new one while scanning through it. Kinda interesting how a basic problem quietly checks whether you understand immutability or just blindly try to edit things in place. #GeeksForGeeks #ProblemOfTheDay #LearningInPublic

While building a recent Spring Boot application, I realized... The Hook: Stop defaulting to .parallelStream() to make your Java code "faster." 🛑 The Insight: It’s a common misconception that parallel streams always improve performance. Under the hood, parallelStream() uses the common ForkJoinPool. If you are executing CPU-intensive tasks on a massive dataset, it’s great. But if you are doing I/O operations (like database calls or network requests) inside that stream, you will exhaust the thread pool and bottleneck your entire application. The Pro Tip: Always benchmark. For I/O bound tasks, look into asynchronous programming (like CompletableFuture) or Java 21's Virtual Threads instead of parallel streams. #Java #PerformanceOptimization #SoftwareEngineering #CleanCode

Most backend performance issues don’t come from bad code. They come from not understanding how the system behaves under load. While exploring Java 21, I tried to connect a few important pieces: • JVM latency improvements with ZGC • Virtual Threads (Project Loom) for concurrency • SQL patterns that impact real performance • Reflection vs Method Handles Put everything into a single visual to make it easier to revise. If you're preparing for backend roles, this might be useful to keep handy. Which part of backend performance do you find hardest to understand? #Java #Java21 #SpringBoot #BackendDevelopment #SystemDesign #PerformanceOptimization #SQL #SoftwareEngineering #java

Day 65 - DSA Practice Solved LeetCode 237 – Delete Node in a Linked List. The catch is you don’t get the head or the previous node, so the usual deletion approach doesn’t work. Instead, copy the value from the next node and link to the node after it. This effectively removes the given node. Simple problem, but a good reminder to think differently when constraints block the obvious approach. #DSA #LeetCode #Java

Java just quietly changed how servers handle millions of requests. And most developers haven't noticed yet. I'm talking about Virtual Threads — introduced in Java 21 (LTS). 🧵 Before Virtual Threads: → 1 request = 1 OS thread → OS threads are expensive (~1MB stack each) → 10,000 requests = system struggling → The only fix was reactive programming (complex, hard to debug) After Virtual Threads: → Millions of virtual threads, managed by the JVM → Blocking a virtual thread doesn't block an OS thread → Write simple, readable blocking code — JVM handles the rest → No reactive spaghetti needed How easy is it to use? Thread.ofVirtual().start(() -> handleRequest(req)); Spring Boot 3.2+ supports it out of the box. Set spring.threads.virtual.enabled=true and you're done. This is Project Loom — years in the making. Production-ready right now. If your team is still on Java 8 or 11 — it's time to have that upgrade conversation. Have you tried Virtual Threads yet? Drop your experience below 👇 #Java #Java21 #VirtualThreads #ProjectLoom #BackendDevelopment #SpringBoot