Daniel Witkowski’s Post

Oracle is ending GraalVM support after JDK 24. The visual below compares key platforms such as vanilla OpenJDK, Azul Platform Prime, GraalVM & Semeru , across JDK features, latency, and cloud-readiness. Take a look at your options: java.azul.com/3J3PuY7 #Java #GraalVM

If you’re working with Java and GraalVM, heads up: Oracle is ending commercial support after JDK 24. This guide breaks down what it means and how to future-proof your stack: https://lnkd.in/dDeTj-r2 #Java #GraalVM

If you’re working with Java and GraalVM, heads up: Oracle is ending commercial support after JDK 24. This guide breaks down what it means and how to future-proof your stack: https://lnkd.in/gwGmh887 #Java #GraalVM

Java teams: big changes ahead. Oracle is ending GraalVM commercial support after JDK 24. This sneak peek shows how leading runtimes compare from OpenJDK to GraalVM Native Image. Full breakdown here: java.azul.com/3J3PuY7 #Java #GraalVM 

🧠 Traditional Threads vs Virtual Threads - Java 21 (JEP 444, Project Loom) 🍁 What Are They? Virtual Threads are lightweight, JVM-managed threads that let your app handle tens of thousands of concurrent tasks — without the overhead of OS threads. 🧵 Before Java 21: Platform Threads - Each thread = 1 OS thread → heavy, limited by system resources. - Blocking calls waste memory and CPU. - It creates bottlenecks, high context-switching cost, and complex async workarounds. ⚡ Now in Virtual Threads - Each thread = lightweight task managed by the JVM. - Blocking is no longer a problem — threads park instead of blocking OS resources. 💡 Why It Matters - Massive scalability — 100k+ concurrent requests with ease - No code rewrites — works with existing APIs (Thread, ExecutorService, etc.) - Ideal for I/O-bound apps — servers, microservices, DB access #Java21 #VirtualThreads #ProjectLoom #Concurrency #BackendDevelopment #SpringBoot #JavaDeveloper

⚡ Java 21 Virtual Threads in real APIs Swapped a blocking fan-out (DB + 2 downstream calls) to virtual threads—same code style, way more concurrency, fewer timeouts. Why it works: I/O-heavy workloads, simpler thread management, smoother bursts. Tip: keep timeouts/back-pressure; CPU-bound stays on platform threads. #Java #Java21 #VirtualThreads #SpringBoot #Performance #Concurrency 🚀

Just published a deep-dive on Java Memory Management , the guide I wish I had years ago. In the article, I break down: ➡️ Heap vs Native memory ➡️Thread stack sizing ➡️GC tuning (HotSpot & OpenJ9) ➡️Metaspace, class caches & direct memory ➡️Tomcat thread pool tuning ➡️Monitoring with Prometheus ➡️Real-world OOM troubleshooting Whether you run Tomcat, Spring Boot, or any JVM-based service, this is the definitive guide to avoiding hidden memory traps. Read it here: https://lnkd.in/dfDUkHs3 #Java #JVM #OpenJDK #OpenJ9 #Tomcat #SRE #Performance #DevOps #BackendEngineering

Java 21: the 5-minute change that boosted our throughput by 27%. We swapped a blocking REST endpoint to use virtual threads in Spring Boot. Same code, better scalability under load. What changed Tomcat thread pool stayed small, but each request got its own virtual thread DB calls still block—but now they don’t burn platform threads Tail latency dropped because queues stopped growing How to try ? Use JDK 21 Add spring.threads.virtual.enabled=true (Spring Boot 3.2+) Keep your blocking JDBC; measure before/after Results (our case) +27% throughput @ p95 ≤ previous p95 Fewer timeouts during peak hour Not a silver bullet—watch JDBC pool, DB CPU, and backpressure. Have you rolled virtual threads to prod yet? What did you see? #Java21 #SpringBoot #Performance #Microservices #Engineering

The full JDK lineup is here! You can now use every major Java 25 build, including IBM Semeru powered by OpenJ9. 👏 Check out our blog post to learn how to install the latest JDK in your IDE. 👇 https://jb.gg/r70wns

🧠 Thread vs ThreadPool — The Hidden Performance Difference Ever created a new thread for every task? It works… until it doesn’t. 🧵 Threads Each thread = its own memory Creating hundreds can kill performance. ✅ Fine for simple, one-off tasks ❌ Not scalable for high-load systems 🏊♂️ ThreadPool (ExecutorService) Instead of creating new threads, it reuses a pool of them. Tasks queue up, and free threads pick them up. ✅ Efficient, scalable, and avoids resource exhaustion 💡 Example: ExecutorService pool = Executors.newFixedThreadPool(10); pool.submit(() -> doWork()); ⚙️ The magic: Spring Boot, Tomcat, and even modern async frameworks use thread pools internally to handle concurrent requests efficiently. 💬 What’s your go-to strategy for managing concurrency? #Java #SpringBoot #Concurrency #Multithreading #SystemDesign #BackendDevelopment #PerformanceEngineering